From f5df416fd9b9d428aaf8c997e50b89c2710a010f Mon Sep 17 00:00:00 2001 From: Kiyoshi Aman Date: Tue, 9 Oct 2018 08:21:38 -0500 Subject: user/lua-socket: new package for lua-sec & prosody --- ...et-on-first-sendto-if-family-agnostic-udp.patch | 49 + user/lua-socket/APKBUILD | 41 + user/lua-socket/git.patch | 6609 ++++++++++++++++++++ user/lua-socket/lua-cflags.patch | 22 + 4 files changed, 6721 insertions(+) create mode 100644 user/lua-socket/0001-Create-socket-on-first-sendto-if-family-agnostic-udp.patch create mode 100644 user/lua-socket/APKBUILD create mode 100644 user/lua-socket/git.patch create mode 100644 user/lua-socket/lua-cflags.patch (limited to 'user/lua-socket') diff --git a/user/lua-socket/0001-Create-socket-on-first-sendto-if-family-agnostic-udp.patch b/user/lua-socket/0001-Create-socket-on-first-sendto-if-family-agnostic-udp.patch new file mode 100644 index 000000000..61bae6fbf --- /dev/null +++ b/user/lua-socket/0001-Create-socket-on-first-sendto-if-family-agnostic-udp.patch @@ -0,0 +1,49 @@ +From 3041a808c3797e3c87272d71666e7b2f7c7a9f46 Mon Sep 17 00:00:00 2001 +From: Natanael Copa +Date: Wed, 25 Jan 2017 12:43:29 +0100 +Subject: [PATCH] Create socket on first sendto if family agnostic udp() was + used + +Create socket and set family on first sendto() if udp() was created +without address family. + +Signed-off-by: Natanael Copa +--- + src/udp.c | 21 +++++++++++++++++++++ + 1 file changed, 21 insertions(+) + +diff --git a/src/udp.c b/src/udp.c +index ec97252..605c195 100644 +--- a/src/udp.c ++++ b/src/udp.c +@@ -189,6 +189,27 @@ static int meth_sendto(lua_State *L) { + lua_pushstring(L, gai_strerror(err)); + return 2; + } ++ ++ /* create socket if on first sendto if AF_UNSPEC was set */ ++ if (udp->family == AF_UNSPEC && udp->sock == SOCKET_INVALID) { ++ struct addrinfo *ap; ++ const char *errstr = NULL; ++ for (ap = ai; ap != NULL; ap = ap->ai_next) { ++ errstr = inet_trycreate(&udp->sock, ap->ai_family, SOCK_DGRAM, 0); ++ if (errstr == NULL) { ++ socket_setnonblocking(&udp->sock); ++ udp->family = ap->ai_family; ++ break; ++ } ++ } ++ if (errstr != NULL) { ++ lua_pushnil(L); ++ lua_pushstring(L, errstr); ++ freeaddrinfo(ai); ++ return 2; ++ } ++ } ++ + timeout_markstart(tm); + err = socket_sendto(&udp->sock, data, count, &sent, ai->ai_addr, + (socklen_t) ai->ai_addrlen, tm); +-- +2.11.0 + diff --git a/user/lua-socket/APKBUILD b/user/lua-socket/APKBUILD new file mode 100644 index 000000000..16bfbcf40 --- /dev/null +++ b/user/lua-socket/APKBUILD @@ -0,0 +1,41 @@ +# Contributor: Mika Havela +# Maintainer: Kiyoshi Aman +pkgname=lua-socket +_name=luasocket +pkgver=3.0_rc1_git20160306 +pkgrel=0 +_ver=${pkgver%_git*} +_ver=${_ver/_rc/-rc} +pkgdesc="Networking library for Lua" +url="http://luaforge.net/projects/luasocket/" +arch="all" +license="MIT" +depends="lua5.3" +makedepends="lua5.3-dev" +source="luasocket-$_ver.tar.gz::https://github.com/diegonehab/luasocket/archive/v$_ver.tar.gz + git.patch + lua-cflags.patch + 0001-Create-socket-on-first-sendto-if-family-agnostic-udp.patch" +builddir="$srcdir/$_name-$_ver" + +build() { + cd "$builddir" + make LUAV="" +} + +check() { + cd "$builddir" + mkdir -p src/socket && cp src/socket-$_ver.so src/socket/core.so + mkdir -p src/mime && cp src/mime-1.0.3.so src/mime/core.so + LUA_CPATH=./src/?.so LUA_PATH="./src/?.lua;;" lua test/hello.lua +} + +package() { + cd "$builddir" + make prefix=/usr DESTDIR="$pkgdir" LUAV="5.3" install-unix +} + +sha512sums="f6efce259aaacaa11472911471f8a13b118fe009b8953a82c6aa18b9ec829cd1293180904e56935cb130d36d267e3f27c91db2d78e03f7488f3e100571ed0540 luasocket-3.0-rc1.tar.gz +45c80e488fedc879f0217bc8a654d80da003039f5d1ff21b0dea0eb769151787dbe793e44a3dfd72cb07ff2697eceaf4fc7b55b4634cd170fa71281f19f025a5 git.patch +61c15238a2f116b7239fdbdb8f617c82dbbecd0117c6e8389b12015bf07f3978299a8e8995e93a45a23530c747662b08d161073cdb6a8e07c4f449e45856e8cb lua-cflags.patch +c45a12e17771a1b3b71154b5415421f524cd10b7969b4649a5f37b652cdc826721e117edb8fe64758d3520e59946e2f755b814f72cbb39ff42bf59bbcf9a64e9 0001-Create-socket-on-first-sendto-if-family-agnostic-udp.patch" diff --git a/user/lua-socket/git.patch b/user/lua-socket/git.patch new file mode 100644 index 000000000..d665fc232 --- /dev/null +++ b/user/lua-socket/git.patch @@ -0,0 +1,6609 @@ +diff --git a/doc/http.html b/doc/http.html +index cd41c0d..3b7a8b1 100644 +--- a/doc/http.html ++++ b/doc/http.html +@@ -112,12 +112,15 @@ the HTTP module: +

+ +
    +-
  • PORT: default port used for connections; +-
  • PROXY: default proxy used for connections; ++
  • PROXY: default proxy used for connections; +
  • TIMEOUT: sets the timeout for all I/O operations; +
  • USERAGENT: default user agent reported to server. +
+ ++

++Note: These constants are global. Changing them will also ++change the behavior other code that might be using LuaSocket. ++

+ + + +diff --git a/doc/mime.html b/doc/mime.html +index ae136fd..8cb3507 100644 +--- a/doc/mime.html ++++ b/doc/mime.html +@@ -72,34 +72,6 @@ local mime = require("mime") + +

High-level filters

+ +- +- +-

+-mime.normalize([marker]) +-

+- +-

+-Converts most common end-of-line markers to a specific given marker. +-

+- +-

+-Marker is the new marker. It defaults to CRLF, the canonic +-end-of-line marker defined by the MIME standard. +-

+- +-

+-The function returns a filter that performs the conversion. +-

+- +-

+-Note: There is no perfect solution to this problem. Different end-of-line +-markers are an evil that will probably plague developers forever. +-This function, however, will work perfectly for text created with any of +-the most common end-of-line markers, i.e. the Mac OS (CR), the Unix (LF), +-or the DOS (CRLF) conventions. Even if the data has mixed end-of-line +-markers, the function will still work well, although it doesn't +-guarantee that the number of empty lines will be correct. +-

+ + + +@@ -159,6 +131,35 @@ base64 = ltn12.filter.chain( + ) + + ++ ++ ++

++mime.normalize([marker]) ++

++ ++

++Converts most common end-of-line markers to a specific given marker. ++

++ ++

++Marker is the new marker. It defaults to CRLF, the canonic ++end-of-line marker defined by the MIME standard. ++

++ ++

++The function returns a filter that performs the conversion. ++

++ ++

++Note: There is no perfect solution to this problem. Different end-of-line ++markers are an evil that will probably plague developers forever. ++This function, however, will work perfectly for text created with any of ++the most common end-of-line markers, i.e. the Mac OS (CR), the Unix (LF), ++or the DOS (CRLF) conventions. Even if the data has mixed end-of-line ++markers, the function will still work well, although it doesn't ++guarantee that the number of empty lines will be correct. ++

++ + + +

+@@ -466,7 +467,7 @@ marker. +

+ + Last modified by Diego Nehab on
+-Thu Apr 20 00:25:44 EDT 2006 ++Fri Mar 4 15:19:17 BRT 2016 + +

+ +diff --git a/doc/reference.css b/doc/reference.css +index b1dd25d..04e38cf 100644 +--- a/doc/reference.css ++++ b/doc/reference.css +@@ -2,6 +2,7 @@ body { + margin-left: 1em; + margin-right: 1em; + font-family: "Verdana", sans-serif; ++ background: #ffffff; + } + + tt { +diff --git a/doc/reference.html b/doc/reference.html +index e9bb5eb..287dc19 100644 +--- a/doc/reference.html ++++ b/doc/reference.html +@@ -147,6 +147,7 @@ Support, Manual"> + connect, + connect4, + connect6, ++_DATAGRAMSIZE, + _DEBUG, + dns, + gettime, +@@ -158,11 +159,14 @@ Support, Manual"> + skip, + sleep, + _SETSIZE, ++_SOCKETINVALID, + source, + tcp, ++tcp4, + tcp6, + try, + udp, ++udp4, + udp6, + _VERSION. + +@@ -183,6 +187,7 @@ Support, Manual"> + getpeername, + getsockname, + getstats, ++gettimeout, + listen, + receive, + send, +@@ -203,6 +208,7 @@ Support, Manual"> + getoption, + getpeername, + getsockname, ++gettimeout, + receive, + receivefrom, + send, +diff --git a/doc/smtp.html b/doc/smtp.html +index bbbff80..600ec37 100644 +--- a/doc/smtp.html ++++ b/doc/smtp.html +@@ -114,6 +114,124 @@ the SMTP module: +
  • ZONE: default time zone. + + ++ ++ ++

    ++smtp.message(mesgt) ++

    ++ ++

    ++Returns a simple ++LTN12 source that sends an SMTP message body, possibly multipart (arbitrarily deep). ++

    ++ ++

    ++The only parameter of the function is a table describing the message. ++Mesgt has the following form (notice the recursive structure): ++

    ++ ++
    ++ ++ ++
    ++mesgt = {
    ++  headers = header-table,
    ++  body = LTN12 source or string or ++multipart-mesgt
    ++}
    ++ 
    ++multipart-mesgt = {
    ++  [preamble = string,]
    ++  [1] = mesgt,
    ++  [2] = mesgt,
    ++  ...
    ++  [n] = mesgt,
    ++  [epilogue = string,]
    ++}
    ++
    ++
    ++ ++

    ++For a simple message, all that is needed is a set of headers ++and the body. The message body can be given as a string ++or as a simple ++LTN12 ++source. For multipart messages, the body is a table that ++recursively defines each part as an independent message, plus an optional ++preamble and epilogue. ++

    ++ ++

    ++The function returns a simple ++LTN12 ++source that produces the ++message contents as defined by mesgt, chunk by chunk. ++Hopefully, the following ++example will make things clear. When in doubt, refer to the appropriate RFC ++as listed in the introduction.

    ++ ++
    ++-- load the smtp support and its friends
++local smtp = require("socket.smtp")
++local mime = require("mime")
++local ltn12 = require("ltn12")
++
++-- creates a source to send a message with two parts. The first part is 
++-- plain text, the second part is a PNG image, encoded as base64.
++source = smtp.message{
++  headers = {
++     -- Remember that headers are *ignored* by smtp.send. 
++     from = "Sicrano de Oliveira <sicrano@example.com>",
++     to = "Fulano da Silva <fulano@example.com>",
++     subject = "Here is a message with attachments"
++  },
++  body = {
++    preamble = "If your client doesn't understand attachments, \r\n" ..
++               "it will still display the preamble and the epilogue.\r\n" ..
++               "Preamble will probably appear even in a MIME enabled client.",
++    -- first part: no headers means plain text, us-ascii.
++    -- The mime.eol low-level filter normalizes end-of-line markers.
++    [1] = { 
++      body = mime.eol(0, [[
++        Lines in a message body should always end with CRLF. 
++        The smtp module will *NOT* perform translation. However, the 
++        send function *DOES* perform SMTP stuffing, whereas the message
++        function does *NOT*.
++      ]])
++    },
++    -- second part: headers describe content to be a png image, 
++    -- sent under the base64 transfer content encoding.
++    -- notice that nothing happens until the message is actually sent. 
++    -- small chunks are loaded into memory right before transmission and 
++    -- translation happens on the fly.
++    [2] = { 
++      headers = {
++        ["content-type"] = 'image/png; name="image.png"',
++        ["content-disposition"] = 'attachment; filename="image.png"',
++        ["content-description"] = 'a beautiful image',
++        ["content-transfer-encoding"] = "BASE64"
++      },
++      body = ltn12.source.chain(
++        ltn12.source.file(io.open("image.png", "rb")),
++        ltn12.filter.chain(
++          mime.encode("base64"),
++          mime.wrap()
++        )
++      )
++    },
++    epilogue = "This might also show up, but after the attachments"
++  }
++}
++
++-- finally send it
++r, e = smtp.send{
++    from = "<sicrano@example.com>",
++    rcpt = "<fulano@example.com>",
++    source = source,
++}
++
    ++ ++ + + +

    +@@ -275,123 +393,6 @@ r, e = smtp.send{ + } + + +- +- +-

    +-smtp.message(mesgt) +-

    +- +-

    +-Returns a simple +-LTN12 source that sends an SMTP message body, possibly multipart (arbitrarily deep). +-

    +- +-

    +-The only parameter of the function is a table describing the message. +-Mesgt has the following form (notice the recursive structure): +-

    +- +-
    +- +- +-
    +-mesgt = {
    +-  headers = header-table,
    +-  body = LTN12 source or string or +-multipart-mesgt
    +-}
    +- 
    +-multipart-mesgt = {
    +-  [preamble = string,]
    +-  [1] = mesgt,
    +-  [2] = mesgt,
    +-  ...
    +-  [n] = mesgt,
    +-  [epilogue = string,]
    +-}
    +-
    +-
    +- +-

    +-For a simple message, all that is needed is a set of headers +-and the body. The message body can be given as a string +-or as a simple +-LTN12 +-source. For multipart messages, the body is a table that +-recursively defines each part as an independent message, plus an optional +-preamble and epilogue. +-

    +- +-

    +-The function returns a simple +-LTN12 +-source that produces the +-message contents as defined by mesgt, chunk by chunk. +-Hopefully, the following +-example will make things clear. When in doubt, refer to the appropriate RFC +-as listed in the introduction.

    +- +-
    +--- load the smtp support and its friends
+-local smtp = require("socket.smtp")
+-local mime = require("mime")
+-local ltn12 = require("ltn12")
+-
+--- creates a source to send a message with two parts. The first part is 
+--- plain text, the second part is a PNG image, encoded as base64.
+-source = smtp.message{
+-  headers = {
+-     -- Remember that headers are *ignored* by smtp.send. 
+-     from = "Sicrano de Oliveira <sicrano@example.com>",
+-     to = "Fulano da Silva <fulano@example.com>",
+-     subject = "Here is a message with attachments"
+-  },
+-  body = {
+-    preamble = "If your client doesn't understand attachments, \r\n" ..
+-               "it will still display the preamble and the epilogue.\r\n" ..
+-               "Preamble will probably appear even in a MIME enabled client.",
+-    -- first part: no headers means plain text, us-ascii.
+-    -- The mime.eol low-level filter normalizes end-of-line markers.
+-    [1] = { 
+-      body = mime.eol(0, [[
+-        Lines in a message body should always end with CRLF. 
+-        The smtp module will *NOT* perform translation. However, the 
+-        send function *DOES* perform SMTP stuffing, whereas the message
+-        function does *NOT*.
+-      ]])
+-    },
+-    -- second part: headers describe content to be a png image, 
+-    -- sent under the base64 transfer content encoding.
+-    -- notice that nothing happens until the message is actually sent. 
+-    -- small chunks are loaded into memory right before transmission and 
+-    -- translation happens on the fly.
+-    [2] = { 
+-      headers = {
+-        ["content-type"] = 'image/png; name="image.png"',
+-        ["content-disposition"] = 'attachment; filename="image.png"',
+-        ["content-description"] = 'a beautiful image',
+-        ["content-transfer-encoding"] = "BASE64"
+-      },
+-      body = ltn12.source.chain(
+-        ltn12.source.file(io.open("image.png", "rb")),
+-        ltn12.filter.chain(
+-          mime.encode("base64"),
+-          mime.wrap()
+-        )
+-      )
+-    },
+-    epilogue = "This might also show up, but after the attachments"
+-  }
+-}
+-
+--- finally send it
+-r, e = smtp.send{
+-    from = "<sicrano@example.com>",
+-    rcpt = "<fulano@example.com>",
+-    source = source,
+-}
+-
    +- + + +
    +diff --git a/doc/socket.html b/doc/socket.html +index b9303cb..35f8391 100644 +--- a/doc/socket.html ++++ b/doc/socket.html +@@ -51,6 +51,30 @@ To obtain the socket namespace, run: + local socket = require("socket") + + ++ ++ ++

    ++socket.headers.canonic

    ++ ++

    The socket.headers.canonic table ++is used by the HTTP and SMTP modules to translate from ++lowercase field names back into their canonic ++capitalization. When a lowercase field name exists as a key ++in this table, the associated value is substituted in ++whenever the field name is sent out. ++

    ++ ++

    ++You can obtain the headers namespace if case run-time ++modifications are required by running: ++

    ++ ++
    ++-- loads the headers module 
++local headers = require("headers")
++
    ++ ++ + + +

    +@@ -90,7 +114,7 @@ of connect are defined as simple helper functions that restrict the + + + +-

    ++

    + socket._DEBUG +

    + +@@ -99,6 +123,19 @@ This constant is set to true if the library was compiled + with debug support. +

    + ++ ++ ++

    ++socket._DATAGRAMSIZE ++

    ++ ++

    ++Default datagram size used by calls to ++receive and ++receivefrom. ++(Unless changed in compile time, the value is 8192.) ++

    ++ + + +

    +@@ -106,8 +143,7 @@ socket.gettime() +

    + +

    +-Returns the time in seconds, relative to the origin of the +-universe. You should subtract the values returned by this function ++Returns the UNIX time in seconds. You should subtract the values returned by this function + to get meaningful values. +

    + +@@ -117,29 +153,6 @@ t = socket.gettime() + print(socket.gettime() - t .. " seconds elapsed") + + +- +- +-

    +-socket.headers.canonic

    +- +-

    The socket.headers.canonic table +-is used by the HTTP and SMTP modules to translate from +-lowercase field names back into their canonic +-capitalization. When a lowercase field name exists as a key +-in this table, the associated value is substituted in +-whenever the field name is sent out. +-

    +- +-

    +-You can obtain the headers namespace if case run-time +-modifications are required by running: +-

    +- +-
    +--- loads the headers module 
+-local headers = require("headers")
+-
    +- + + +

    +@@ -155,8 +168,7 @@ is raised. + +

    + Finalizer is a function that will be called before +-try throws the exception. It will be called +-in protected mode. ++try throws the exception. +

    + +

    +@@ -204,15 +216,9 @@ to throw exceptions. +

    + +

    +-Returns an equivalent function that instead of throwing exceptions, +-returns nil followed by an error message. +-

    +- +-

    +-Note: Beware that if your function performs some illegal operation that +-raises an error, the protected function will catch the error and return it +-as a string. This is because the try function +-uses errors as the mechanism to throw exceptions. ++Returns an equivalent function that instead of throwing exceptions in case of ++a failed try call, returns nil ++followed by an error message. +

    + + +@@ -238,7 +244,9 @@ non-numeric indices) in the arrays will be silently ignored. + +

    The function returns a list with the sockets ready for + reading, a list with the sockets ready for writing and an error message. +-The error message is "timeout" if a timeout condition was met and ++The error message is "timeout" if a timeout ++condition was met, "select failed" if the call ++to select failed, and + nil otherwise. The returned tables are + doubly keyed both by integers and also by the sockets + themselves, to simplify the test if a specific socket has +@@ -246,7 +254,7 @@ changed status. +

    + +

    +-Note: : select can monitor a limited number ++Note: select can monitor a limited number + of sockets, as defined by the constant socket._SETSIZE. This + number may be as high as 1024 or as low as 64 by default, + depending on the system. It is usually possible to change this +@@ -276,6 +284,18 @@ it to select, it will be ignored. + Using select with non-socket objects: Any object that implements getfd and dirty can be used with select, allowing objects from other libraries to be used within a socket.select driven loop. +

    + ++ ++ ++

    ++socket._SETSIZE ++

    ++ ++

    ++The maximum number of sockets that the select function can handle. ++

    ++ ++ + + +

    +@@ -383,15 +403,14 @@ side closes the connection. + The function returns a source with the appropriate behavior. +

    + +- ++ + +-

    +-socket._SETSIZE ++

    ++socket._SOCKETINVALID +

    + +

    +-The maximum number of sockets that the select function can handle. ++The OS value for an invalid socket. +

    + + +@@ -401,9 +420,9 @@ socket.try(ret1 [, ret2 ... retN]) + +

    +-Throws an exception in case of error. The exception can only be caught +-by the protect function. It does not explode +-into an error message. ++Throws an exception in case ret1 is falsy, using ++ret2 as the error message. The exception is supposed to be caught ++by a protected function only. +

    + +

    +@@ -414,7 +433,10 @@ nested with try. + +

    + The function returns ret1 to retN if +-ret1 is not nil. Otherwise, it calls error passing ret2. ++ret1 is not nil or false. ++Otherwise, it calls error passing ret2 wrapped ++in a table with metatable used by protect to ++distinguish exceptions from runtime errors. +

    + + 
    +diff --git a/doc/tcp.html b/doc/tcp.html
+index 4226d78..c6c6eb2 100644
+--- a/doc/tcp.html
++++ b/doc/tcp.html
+@@ -1,10 +1,10 @@
+-
+ 
+ 
+ 
+ 
+- 
++
+ LuaSocket: TCP/IP support
+ 
+ 
+@@ -28,7 +28,7 @@
+ download ·
+ installation ·
+ introduction ·
+-reference 
++reference
+ 
    
+ 
+ 
    
+@@ -36,56 +36,11 @@
+ 
+ 
+ 
+-
    TCP
     
+-
+-
+-
+-
     
+-socket.tcp()
+-
    
+-
+-
     
+-Creates and returns an IPv4 TCP master object. A master object can
+-be transformed into a server object with the method 
+-listen (after a call to bind) or into a client object with 
+-the method connect. The only other 
+-method supported by a master object is the 
+-close method.
    
+-
+-
    
+-In case of success, a new master object is returned. In case of error,
+-nil is returned, followed by an error message.
+-
    
+-
+-
+-
+-
     
+-socket.tcp6()
+-
    
+-
+-
     
+-Creates and returns an IPv6 TCP master object. A master object can
+-be transformed into a server object with the method 
+-listen (after a call to bind) or into a client object with 
+-the method connect. The only other 
+-method supported by a master object is the 
+-close method.
    
+-
+-
    
+-In case of success, a new master object is returned. In case of error,
+-nil is returned, followed by an error message.
+-
    
+-
+-
    
+-Note: The TCP object returned will have the option
+-"ipv6-v6only" set to true.
+-
    
++
    TCP
    
+ 
+ 
+ 
+-
     
++
    
+ server:accept()
+ 
    
+ 
+@@ -95,9 +50,9 @@ object and returns a client object representing that connection.
+ 
    
+ 
+ 
    
+-If a connection is successfully initiated, a client object is returned.  
++If a connection is successfully initiated, a client object is returned.
+ If a  timeout condition  is  met,  the method  returns nil
+-followed by the error string 'timeout'. Other errors are 
++followed by the error string 'timeout'. Other errors are
+ reported by nil followed by a message describing the error.
+ 
    
+ 
+@@ -107,28 +62,28 @@ with   a  server   object   in
+ the recvt  parameter  before  a   call  to  accept does
+ not guarantee  accept will  return immediately.  Use the settimeout method or accept
+-might block until another client shows up. 
++might block until another client shows up.
+ 
    
+ 
+ 
+ 
+-
     
++
    
+ master:bind(address, port)
+ 
    
+ 
+ 
    
+ Binds a master object to address and port on the
+-local host. 
++local host.
+ 
+ 
    
+-Address can be an IP address or a host name. 
+-Port must be an integer number in the range [0..64K). 
++Address can be an IP address or a host name.
++Port must be an integer number in the range [0..64K).
+ If address
+ is '*', the system binds to all local interfaces
+ using the INADDR_ANY constant or
+-IN6ADDR_ANY_INIT, according to the family. 
++IN6ADDR_ANY_INIT, according to the family.
+ If port is 0, the system automatically
+-chooses an ephemeral port.  
++chooses an ephemeral port.
+ 
    
+ 
+ 
    
+@@ -137,13 +92,13 @@ method returns nil followed by an error message.
+ 
    
+ 
+ 
    
+-Note: The function socket.bind 
++Note: The function socket.bind
+ is available and is a shortcut for the creation of server sockets.
+ 
    
+ 
+ 
+ 
+-
     
++
    
+ master:close()
    
+ client:close()
    
+ server:close()
+@@ -154,14 +109,14 @@ Closes  a TCP object. The internal socket used by the object is closed
+ and the local  address   to  which the object was
+ bound is made  available to other  applications. No further  operations
+ (except  for  further calls  to the close method)  are allowed on
+-a closed socket. 
++a closed socket.
+ 
    
+ 
+ 
    
+ Note:  It is  important to  close all  used  sockets once  they are  not
+ needed,  since, in  many systems,  each socket  uses a  file descriptor,
+ which are limited system resources. Garbage-collected objects are
+-automatically closed before destruction, though. 
++automatically closed before destruction, though.
+ 
    
+ 
+ 
+@@ -172,19 +127,19 @@ master:connect(address, port)
+ 
+ 
    
+ Attempts to connect a master object to a remote host, transforming it into a
+-client object. 
+-Client objects support methods 
++client object.
++Client objects support methods
+ send,
+-receive, 
+-getsockname, 
++receive,
++getsockname,
+ getpeername,
+-settimeout, 
++settimeout,
+ and close.
+ 
    
+ 
+ 
    
+-Address can be an IP address or a host name. 
+-Port must be an integer number in the range [1..64K). 
++Address can be an IP address or a host name.
++Port must be an integer number in the range [1..64K).
+ 
    
+ 
+ 
    
+@@ -193,14 +148,14 @@ describing the error. In case of success, the method returns 1.
+ 
    
+ 
+ 
    
+-Note: The function socket.connect 
++Note: The function socket.connect
+ is available and is a shortcut for the creation of client sockets.
+ 
    
+ 
+ 
    
+-Note: Starting with LuaSocket 2.0, 
++Note: Starting with LuaSocket 2.0,
+ the settimeout
+-method affects the behavior of connect, causing it to return 
++method affects the behavior of connect, causing it to return
+ with an error in case of a timeout. If that happens, you can still call socket.select with the socket in the
+ sendt table. The socket will be writable when the connection is
+@@ -209,13 +164,88 @@ established.
+ 
+ 
    
+ Note: Starting with LuaSocket 3.0, the host name resolution
+-depends on whether the socket was created by socket.tcp or socket.tcp6. Addresses from
+-the appropriate family are tried in succession until the
+-first success or until the last failure.
++depends on whether the socket was created by
++socket.tcp,
++socket.tcp4 or
++socket.tcp6. Addresses from
++the appropriate family (or both) are tried in the order
++returned by the resolver until the
++first success or until the last failure. If the timeout was
++set to zero, only the first address is tried.
++
    
++
++
++
++
    
++master:dirty()
    
++client:dirty()
    
++server:dirty()
++
    
++
++
    
++Check the read buffer status.
++
    
++
++
    
++Returns true if there is any data in the read buffer, false otherwise.
++
    
++
++
    
++Note: This is an internal method, use at your own risk.
++
    
++
++
++
++
++
    
++master:getfd()
    
++client:getfd()
    
++server:getfd()
++
    
++
++
    
++Returns the underling socket descriptor or handle associated to the object.
++
    
++
++
    
++The descriptor or handle. In case the object has been closed, the return will be -1.
++
    
++
++
    
++Note: This is an internal method. Unlikely to be
++portable. Use at your own risk. 
++
    
++
++
++
++
++
    
++client:getoption(option)
    
++server:getoption(option)
++
    
++
++
    
++Gets options for the TCP object.
++See setoption for description of the
++option names and values.
++
    
++
++
    
++Option is a string with the option name.
++
      
++
++
    •  'keepalive'
++
    •  'linger'
++
    •  'reuseaddr'
++
    •  'tcp-nodelay'
++
    
++
++
    
++The method returns the option value in case of success, or
++nil followed by an error message otherwise.
+ 
    
+ 
++
+ 
+ 
+ 
    
+@@ -227,10 +257,10 @@ Returns information about the remote side of a connected client object.
+ 
    
+ 
+ 
    
+-Returns a string with the IP address of the peer, the 
+-port number that peer is using for the connection, 
+-and a string with the family ("inet" or "inet6"). 
+-In case of error, the method returns nil. 
++Returns a string with the IP address of the peer, the
++port number that peer is using for the connection,
++and a string with the family ("inet" or "inet6").
++In case of error, the method returns nil.
+ 
    
+ 
+ 
    
+@@ -246,13 +276,13 @@ server:getsockname()
+ 
    
+ 
+ 
    
+-Returns the local address information associated to the object. 
++Returns the local address information associated to the object.
+ 
    
+ 
+ 
    
+-The method returns a string with local IP address, a number with 
+-the local port, 
+-and a string with the family ("inet" or "inet6"). 
++The method returns a string with local IP address, a number with
++the local port,
++and a string with the family ("inet" or "inet6").
+ In case of error, the method returns nil.
+ 
    
+ 
+@@ -266,32 +296,46 @@ server:getstats()
    
+ 
+ 
    
+ Returns accounting information on the socket, useful for throttling
+-of bandwidth. 
++of bandwidth.
+ 
    
+ 
+ 
    
+ The method returns the number of bytes received, the number of bytes sent,
+-and the age of the socket object in seconds. 
++and the age of the socket object in seconds.
+ 
    
+ 
++
++
++
    
++master:gettimeout()
    
++client:gettimeout()
    
++server:gettimeout()
++
    
++
++
    
++Returns the current block timeout followed by the curent
++total timeout.
++
    
++
++
+ 
+ 
+-
     
++
    
+ master:listen(backlog)
+ 
    
+ 
+ 
    
+ Specifies the socket is willing to receive connections, transforming the
+-object into a server object.  Server objects support the 
+-accept,  
+-getsockname, 
+-setoption, 
+-settimeout, 
+-and close methods.  
++object into a server object.  Server objects support the
++accept,
++getsockname,
++setoption,
++settimeout,
++and close methods.
+ 
    
+ 
+ 
    
+-The parameter backlog specifies the  number  of  client 
++The parameter backlog specifies the  number  of  client
+ connections that can
+ be queued waiting for service. If the queue is full and another  client
+ attempts connection,  the connection is  refused.
+@@ -310,11 +354,11 @@ client:receive([pattern [, prefix]])
+ 
+ 
    
+ Reads data from a client object, according to the specified read
+-pattern.  Patterns follow the Lua file I/O format, and the difference in performance between all patterns is negligible. 
++pattern.  Patterns follow the Lua file I/O format, and the difference in performance between all patterns is negligible.
+ 
    
+ 
+ 
    
+-Pattern can be any of the following: 
++Pattern can be any of the following:
+ 
    
+ 
+ 
      
+@@ -325,7 +369,7 @@ terminated by a  LF character (ASCII 10), optionally  preceded by a
+ CR character (ASCII 13). The CR and LF characters are not included in
+ the returned line. In fact, all CR characters are
+ ignored by the pattern. This is the default pattern;
+-
    •  number:  causes the  method to read  a specified number 
++
    •  number:  causes the  method to read  a specified number
+ of bytes from the socket.
+ 
    
+ 
+@@ -347,10 +391,10 @@ closed  before  the transmission  was completed  or  the string
+ 
    
+ Important note: This function was changed severely. It used
+ to support multiple patterns (but I have never seen this feature used) and
+-now it doesn't anymore.  Partial results used to be returned in the same 
++now it doesn't anymore.  Partial results used to be returned in the same
+ way as successful results. This last feature violated the idea that all
+ functions should return nil on error.  Thus it was changed
+-too. 
++too.
+ 
    
+ 
+ 
+@@ -366,7 +410,7 @@ Sends data through client object.
+ 
    
+ Data is the string to be sent. The optional arguments
+ i and j work exactly like the standard
+-string.sub Lua function to allow the selection of a 
++string.sub Lua function to allow the selection of a
+ substring to be sent.
+ 
    
+ 
+@@ -385,10 +429,10 @@ there was  a  timeout  during  the operation.
+ 
    
+ 
+ 
    
+-Note: Output is not buffered. For small strings, 
+-it is always better to concatenate them in Lua 
+-(with the '..' operator) and send the result in one call 
+-instead of calling the method several times. 
++Note: Output is not buffered. For small strings,
++it is always better to concatenate them in Lua
++(with the '..' operator) and send the result in one call
++instead of calling the method several times.
+ 
    
+ 
+ 
+@@ -400,12 +444,12 @@ server:setoption(option [, value])
+ 
+ 
    
+ Sets options for the TCP object. Options are only needed by low-level or
+-time-critical applications. You should only modify an option if you 
+-are sure you need it. 
++time-critical applications. You should only modify an option if you
++are sure you need it.
+ 
    
+ 
+ 
    
+-Option is a string with the option name, and value 
++Option is a string with the option name, and value
+ depends on the option being set:
+ 
+ 
      
+@@ -413,7 +457,7 @@ depends on the option being set:
+ 
    •  'keepalive':  Setting this option to true enables
+ the periodic transmission of messages on a connected socket. Should the
+ connected party fail to respond to these messages, the connection is
+-considered broken and processes using the socket are notified; 
++considered broken and processes using the socket are notified;
+ 
+ 
    •  'linger': Controls the action taken when unsent data are
+ queued on a socket and a close is performed.  The value is a table with a
+@@ -424,13 +468,13 @@ it is able to transmit the data or until 'timeout' has passed. If
+ 'on' is false and a close is issued, the system will
+ process the close in a manner that allows the process to continue as
+ quickly as possible. I do not advise you to set this to anything other than
+-zero; 
++zero;
+ 
+ 
    •  'reuseaddr': Setting this option indicates that the rules
+-used in validating addresses supplied in a call to 
++used in validating addresses supplied in a call to
+ bind should allow reuse of local addresses;
+ 
+-
    •  'tcp-nodelay': Setting this option to true 
++
    •  'tcp-nodelay': Setting this option to true
+ disables the Nagle's algorithm for the connection;
+ 
+ 
    •  'ipv6-v6only':
+@@ -447,34 +491,6 @@ followed by an error message otherwise.
+ Note: The descriptions above come from the man pages.
+ 
      
+ 
+-
+-
+-
      
+-client:getoption(option)
      
+-server:getoption(option)
+-
      
+-
+-
      
+-Gets options for the TCP object.
+-See setoption for description of the
+-option names and values.
+-
      
+-
+-
      
+-Option is a string with the option name.
+-
        
+-
+-
      •  'keepalive'
+-
      •  'linger'
+-
      •  'reuseaddr'
+-
      •  'tcp-nodelay'
+-
      
+-
+-
      
+-The method returns the option value in case of success, or
+-nil followed by an error message otherwise.
+-
      
+-
+ 
+ 
+ 
      
+@@ -485,7 +501,7 @@ server:setstats(received, sent, age)
      
+ 
+ 
      
+ Resets accounting information on the socket, useful for throttling
+-of bandwidth. 
++of bandwidth.
+ 
      
+ 
+ 
      
+@@ -495,7 +511,7 @@ of bandwidth.
+ 
      
+ 
+ 
      
+-The method returns 1 in case of success and nil otherwise. 
++The method returns 1 in case of success and nil otherwise.
+ 
      
+ 
+ 
+@@ -509,8 +525,8 @@ server:settimeout(value [, mode])
+ 
      
+ Changes the timeout  values for the object. By default,
+ all I/O  operations are  blocking. That  is, any  call to  the methods
+-send, 
+-receive, and 
++send,
++receive, and
+ accept
+ will  block indefinitely,  until the operation completes.  The
+ settimeout  method defines a  limit on the  amount  of   time  the
+@@ -521,7 +537,7 @@ time has elapsed, the affected methods give up and fail with an error code.
+ 
      
+ The amount of time to wait is specified  as  the
+ value parameter, in seconds. There  are two timeout  modes and
+-both can be used together for fine tuning: 
++both can be used together for fine tuning:
+ 
      
+ 
+ 
        
+@@ -532,7 +548,7 @@ default mode;
+ 
+ 
      •  't':  total timeout. Specifies the  upper limit on
+ the amount of  time LuaSocket can block a Lua  script before returning from
+-a call.
        •  
++a call.
+ 
      
+ 
+ 
      
+@@ -562,7 +578,7 @@ client:shutdown(mode)
      
+ 
      
+ 
+ 
      
+-Shuts down part of a full-duplex connection. 
++Shuts down part of a full-duplex connection.
+ 
      
+ 
+ 
      
+@@ -579,66 +595,107 @@ This is the default mode;
+ This function returns 1.
+ 
      
+ 
+-
++
+ 
+-
      
+-master:dirty()
      
+-client:dirty()
      
+-server:dirty()
++
      
++master:setfd(fd)
      
++client:setfd(fd)
      
++server:setfd(fd)
+ 
      
+ 
+ 
      
+-Check the read buffer status.
++Sets the underling socket descriptor or handle associated to the object. The current one is simply replaced, not closed, and no other change to the object state is made.
+ 
      
+ 
+ 
      
+-Returns true if there is any data in the read buffer, false otherwise.
++No return value.
+ 
      
+ 
+ 
      
+-Note: This is an internal method, any use is unlikely to be portable.
++Note: This is an internal method. Unlikely to be
++portable. Use at your own risk. 
+ 
      
+ 
+-
++
+ 
+-
      
+-master:getfd()
      
+-client:getfd()
      
+-server:getfd()
++
      
++socket.tcp()
+ 
      
+ 
+ 
      
+-Returns the underling socket descriptor or handle associated to the object. 
+-
      
++Creates and returns an TCP master object. A master object can
++be transformed into a server object with the method
++listen (after a call to bind) or into a client object with
++the method connect. The only other
++method supported by a master object is the
++close method.
      
+ 
+ 
      
+-The descriptor or handle. In case the object has been closed, the return will be -1.
++In case of success, a new master object is returned. In case of error,
++nil is returned, followed by an error message.
+ 
      
+ 
+ 
      
+-Note: This is an internal method, any use is unlikely to be portable.
++Note: The choice between IPv4 and IPv6 happens during a call to
++bind or connect, depending on the address
++family obtained from the resolver.
+ 
      
+ 
+-
++
      
++Note: Before the choice between IPv4 and IPv6 happens,
++the internal socket object is invalid and therefore setoption will fail.
++
      
+ 
+-
      
+-master:setfd(fd)
      
+-client:setfd(fd)
      
+-server:setfd(fd)
++
++
++
      
++socket.tcp4()
+ 
      
+ 
+ 
      
+-Sets the underling socket descriptor or handle associated to the object. The current one is simply replaced, not closed, and no other change to the object state is made.
++Creates and returns an IPv4 TCP master object. A master object can
++be transformed into a server object with the method
++listen (after a call to bind) or into a client object with
++the method connect. The only other
++method supported by a master object is the
++close method.
      
++
++
      
++In case of success, a new master object is returned. In case of error,
++nil is returned, followed by an error message.
++
      
++
++
++
++
      
++socket.tcp6()
+ 
      
+ 
++
      
++Creates and returns an IPv6 TCP master object. A master object can
++be transformed into a server object with the method
++listen (after a call to bind) or into a client object with
++the method connect. The only other
++method supported by a master object is the
++close method.
      
++
+ 
      
+-No return value.
++In case of success, a new master object is returned. In case of error,
++nil is returned, followed by an error message.
+ 
      
+ 
+ 
      
+-Note: This is an internal method, any use is unlikely to be portable.
++Note: The TCP object returned will have the option
++"ipv6-v6only" set to true.
+ 
      
+ 
++
++
+ 
+ 
+ 
      
+diff --git a/doc/udp.html b/doc/udp.html
+index e5b0ad0..4618aad 100644
+--- a/doc/udp.html
++++ b/doc/udp.html
+@@ -4,7 +4,7 @@
+ 
+ 
+ 
+- 
++
+ LuaSocket: UDP support
+ 
+ 
+@@ -28,7 +28,7 @@
+ download ·
+ installation ·
+ introduction ·
+-reference 
++reference
+ 
      
+ 
+ 
      
+@@ -37,74 +37,7 @@
+ 
+ 
+ 
+-
      UDP
       
+-
+-
+-
+-
      
+-socket.udp()
+-
      
+-
+-
      
+-Creates and returns an unconnected IPv4 UDP object. 
+-Unconnected objects support the 
+-sendto, 
+-receive, 
+-receivefrom, 
+-getoption, 
+-getsockname, 
+-setoption, 
+-settimeout, 
+-setpeername, 
+-setsockname, and 
+-close. 
+-The setpeername 
+-is used to connect the object.
+-
      
+-
+-
      
+-In case of success, a new unconnected UDP object
+-returned. In case of error, nil is returned, followed by
+-an error message.
+-
      
+-
+-
+-
+-
      
+-socket.udp6()
+-
      
+-
+-
      
+-Creates and returns an unconnected IPv6 UDP object. 
+-Unconnected objects support the 
+-sendto, 
+-receive, 
+-receivefrom, 
+-getoption, 
+-getsockname, 
+-setoption, 
+-settimeout, 
+-setpeername, 
+-setsockname, and 
+-close. 
+-The setpeername 
+-is used to connect the object.
+-
      
+-
+-
      
+-In case of success, a new unconnected UDP object
+-returned. In case of error, nil is returned, followed by
+-an error message.
+-
      
+-
+-
      
+-Note: The TCP object returned will have the option
+-"ipv6-v6only" set to true.
+-
      
+-
+-
+-
+-
++
      UDP
      
+ 
+ 
+ 
+@@ -129,6 +62,40 @@ Garbage-collected objects are automatically closed before
+ destruction, though.
+ 
      
+ 
++
++
++
      
++connected:getoption()
      
++unconnected:getoption()
++
      
++
++
      
++Gets an option value from the UDP object.
++See setoption for
++description of the option names and values.
++
      
++
++
      Option is a string with the option name.
++
        
++
      •  'dontroute'
++
      •  'broadcast'
++
      •  'reuseaddr'
++
      •  'reuseport'
++
      •  'ip-multicast-loop'
++
      •  'ipv6-v6only'
++
      •  'ip-multicast-if'
++
      •  'ip-multicast-ttl'
++
      •  'ip-add-membership'
++
      •  'ip-drop-membership'
++
      
++
      
++
++
      
++The method returns the option value in case of
++success, or
++nil followed by an error message otherwise.
++
      
++
+ 
+ 
+ 
      
+@@ -142,10 +109,10 @@ associated with a connected UDP object.
+ 
+ 
+ 
      
+-Returns a string with the IP address of the peer, the 
+-port number that peer is using for the connection, 
+-and a string with the family ("inet" or "inet6"). 
+-In case of error, the method returns nil. 
++Returns a string with the IP address of the peer, the
++port number that peer is using for the connection,
++and a string with the family ("inet" or "inet6").
++In case of error, the method returns nil.
+ 
      
+ 
+ 
      
+@@ -165,9 +132,9 @@ Returns the local address information associated to the object.
+ 
+ 
+ 
      
+-The method returns a string with local IP address, a number with 
+-the local port, 
+-and a string with the family ("inet" or "inet6"). 
++The method returns a string with local IP address, a number with
++the local port,
++and a string with the family ("inet" or "inet6").
+ In case of error, the method returns nil.
+ 
      
+ 
+@@ -179,6 +146,18 @@ first time (in which case it is bound to an ephemeral port and the
+ wild-card address).
+ 
      
+ 
++
++
++
      
++connected:settimeout(value)
      
++unconnected:settimeout(value)
++
      
++
++
      
++Returns the current timeout value.
++
      
++
++
+ 
+ 
+ 
      
+@@ -199,9 +178,12 @@ specifies the maximum size of the datagram to be retrieved. If
+ there are more than size bytes available in the datagram,
+ the excess bytes are discarded. If there are less then
+ size bytes available in the current datagram, the
+-available bytes are returned. If size is omitted, the
+-maximum datagram size is used (which is currently limited by the
+-implementation to 8192 bytes).
++available bytes are returned.
++If size is omitted, the
++compile-time constant socket._DATAGRAMSIZE is used
++(it defaults to 8192 bytes). Larger sizes will cause a
++temporary buffer to be allocated for the operation.
+ 
      
+ 
+ 
      
+@@ -217,46 +199,12 @@ unconnected:receivefrom([size])
+ 
      
+ 
+ 
      
+-Works exactly as the receive 
++Works exactly as the receive
+ method, except it returns the IP
+ address and port as extra return values (and is therefore slightly less
+ efficient).
+ 
      
+ 
+-
+-
+-
      
+-connected:getoption()
      
+-unconnected:getoption()
+-
      
+-
+-
      
+-Gets an option value from the UDP object.
+-See setoption for
+-description of the option names and values.
+-
      
+-
+-
      Option is a string with the option name. 
+-
        
+-
      •  'dontroute'
+-
      •  'broadcast'
+-
      •  'reuseaddr'
+-
      •  'reuseport'
+-
      •  'ip-multicast-loop'
+-
      •  'ipv6-v6only'
+-
      •  'ip-multicast-if'
+-
      •  'ip-multicast-ttl'
+-
      •  'ip-add-membership' 
+-
      •  'ip-drop-membership'
+-
       
+-
      
+-
+-
      
+-The method returns the option value in case of
+-success, or
+-nil followed by an error message otherwise.
+-
      
+-
+ 
+ 
+ 
      
+@@ -268,7 +216,7 @@ Sends a datagram to the UDP peer of a connected object.
+ 
      
+ 
+ 
      
+-Datagram is a string with the datagram contents. 
++Datagram is a string with the datagram contents.
+ The maximum datagram size for UDP is 64K minus IP layer overhead.
+ However datagrams larger than the link layer packet size will be
+ fragmented, which may deteriorate performance and/or reliability.
+@@ -298,11 +246,11 @@ Sends a datagram to the specified IP address and port number.
+ 
+ 
      
+ Datagram is a string with the
+-datagram contents. 
++datagram contents.
+ The maximum datagram size for UDP is 64K minus IP layer overhead.
+ However datagrams larger than the link layer packet size will be
+ fragmented, which may deteriorate performance and/or reliability.
+-Ip is the IP address of the recipient. 
++Ip is the IP address of the recipient.
+ Host names are not allowed for performance reasons.
+ 
+ Port is the port number at the recipient.
+@@ -320,6 +268,75 @@ refuses to send a message to the specified address (i.e. no
+ interface accepts the address).
+ 
      
+ 
++
++
++
      
++connected:setoption(option [, value])
      
++unconnected:setoption(option [, value])
++
      
++
++
      
++Sets options for the UDP object. Options are
++only needed by low-level or time-critical applications. You should
++only modify an option if you are sure you need it.
      
++
      Option is a string with the option
++name, and value depends on the option being set:
++
      
++
++
        
++
      •  'dontroute': Indicates that outgoing
++messages should bypass the standard routing facilities.
++Receives a boolean value;
++
      •  'broadcast': Requests permission to send
++broadcast datagrams on the socket.
++Receives a boolean value;
++
      •  'reuseaddr': Indicates that the rules used in
++validating addresses supplied in a bind() call
++should allow reuse of local addresses.
++Receives a boolean value;
++
      •  'reuseport': Allows completely duplicate
++bindings by multiple processes if they all set
++'reuseport' before binding the port.
++Receives a boolean value;
++
      •  'ip-multicast-loop':
++Specifies whether or not a copy of an outgoing multicast
++datagram is delivered to the sending host as long as it is a
++member of the multicast group.
++Receives a boolean value;
++
      •  'ipv6-v6only':
++Specifies whether to restrict inet6 sockets to
++sending and receiving only IPv6 packets.
++Receive a boolean value;
++
      •  'ip-multicast-if':
++Sets the interface over which outgoing multicast datagrams
++are sent.
++Receives an IP address;
++
      •  'ip-multicast-ttl':
++Sets the Time To Live in the IP header for outgoing
++multicast datagrams.
++Receives a number;
++
      •  'ip-add-membership':
++Joins the multicast group specified.
++Receives a table with fields
++multiaddr and interface, each containing an
++IP address;
++
      •  'ip-drop-membership': Leaves the multicast
++group specified.
++Receives a table with fields
++multiaddr and interface, each containing an
++IP address.
++
      
++
++
      
++The method returns 1 in case of success, or
++nil followed by an error message otherwise.
++
      
++
++
      
++Note: The descriptions above come from the man pages.
++
      
++
++
+ 
+ 
+ 
      
+@@ -337,9 +354,9 @@ object or vice versa.
+ For connected objects, outgoing datagrams
+ will be sent to the specified peer, and datagrams received from
+ other peers will be discarded by the OS. Connected UDP objects must
+-use the send and 
+-receive methods instead of 
+-sendto and 
++use the send and
++receive methods instead of
++sendto and
+ receivefrom.
+ 
      
+ 
+@@ -406,74 +423,6 @@ system or explicitly by setsockname, it cannot be
+ changed.
+ 
      
+ 
+-
+-
+-
      
+-connected:setoption(option [, value])
      
+-unconnected:setoption(option [, value])
+-
      
+-
+-
      
+-Sets options for the UDP object. Options are
+-only needed by low-level or time-critical applications. You should
+-only modify an option if you are sure you need it.
      
+-
      Option is a string with the option
+-name, and value depends on the option being set:
+-
      
+-
+-
         
+-
      •  'dontroute': Indicates that outgoing
+-messages should bypass the standard routing facilities.
+-Receives a boolean value;
+-
      •  'broadcast': Requests permission to send 
+-broadcast datagrams on the socket.
+-Receives a boolean value;
+-
      •  'reuseaddr': Indicates that the rules used in
+-validating addresses supplied in a bind() call 
+-should allow reuse of local addresses. 
+-Receives a boolean value;
+-
      •  'reuseport': Allows completely duplicate
+-bindings by multiple processes if they all set
+-'reuseport' before binding the port.
+-Receives a boolean value;
+-
      •  'ip-multicast-loop':
+-Specifies whether or not a copy of an outgoing multicast
+-datagram is delivered to the sending host as long as it is a
+-member of the multicast group.
+-Receives a boolean value;
+-
      •  'ipv6-v6only':
+-Specifies whether to restrict inet6 sockets to 
+-sending and receiving only IPv6 packets.
+-Receive a boolean value;
+-
      •  'ip-multicast-if':
+-Sets the interface over which outgoing multicast datagrams
+-are sent.
+-Receives an IP address;
+-
      •  'ip-multicast-ttl':
+-Sets the Time To Live in the IP header for outgoing
+-multicast datagrams. 
+-Receives a number;
+-
      •  'ip-add-membership': 
+-Joins the multicast group specified.
+-Receives a table with fields
+-multiaddr and interface, each containing an
+-IP address;
+-
      •  'ip-drop-membership': Leaves the multicast
+-group specified.
+-Receives a table with fields
+-multiaddr and interface, each containing an
+-IP address.
+-
       
+-
+-
      
+-The method returns 1 in case of success, or
+-nil followed by an error message otherwise.
+-
      
+-
+-
      
+-Note: The descriptions above come from the man pages.
+-
      
+-
+ 
+ 
+ 
      
+@@ -482,14 +431,14 @@ unconnected:settimeout(value)
+ 
      
+ 
+ 
      
+-Changes the timeout values for the object.  By default, the 
+-receive and 
+-receivefrom 
++Changes the timeout values for the object.  By default, the
++receive and
++receivefrom
+ operations are blocking. That is, any call to the methods will block
+ indefinitely, until data arrives.  The settimeout function defines
+ a limit on the amount of time the functions can block. When a timeout is
+ set and the specified amount of time has elapsed, the affected methods
+-give up and fail with an error code.  
++give up and fail with an error code.
+ 
      
+ 
+ 
      
+@@ -514,6 +463,114 @@ all other method names already contained verbs making their
+ imperative nature obvious.
+ 
      
+ 
++
++
++
      
++socket.udp()
++
      
++
++
      
++Creates and returns an unconnected UDP object.
++Unconnected objects support the
++sendto,
++receive,
++receivefrom,
++getoption,
++getsockname,
++setoption,
++settimeout,
++setpeername,
++setsockname, and
++close.
++The setpeername
++is used to connect the object.
++
      
++
++
      
++In case of success, a new unconnected UDP object
++returned. In case of error, nil is returned, followed by
++an error message.
++
      
++
++
      
++Note: The choice between IPv4 and IPv6 happens during a call to
++sendto, setpeername, or sockname, depending on the address
++family obtained from the resolver.
++
      
++
++
      
++Note: Before the choice between IPv4 and IPv6 happens,
++the internal socket object is invalid and therefore setoption will fail.
++
      
++
++
++
++
      
++socket.udp4()
++
      
++
++
      
++Creates and returns an unconnected IPv4 UDP object.
++Unconnected objects support the
++sendto,
++receive,
++receivefrom,
++getoption,
++getsockname,
++setoption,
++settimeout,
++setpeername,
++setsockname, and
++close.
++The setpeername
++is used to connect the object.
++
      
++
++
      
++In case of success, a new unconnected UDP object
++returned. In case of error, nil is returned, followed by
++an error message.
++
      
++
++
++
++
      
++socket.udp6()
++
      
++
++
      
++Creates and returns an unconnected IPv6 UDP object.
++Unconnected objects support the
++sendto,
++receive,
++receivefrom,
++getoption,
++getsockname,
++setoption,
++settimeout,
++setpeername,
++setsockname, and
++close.
++The setpeername
++is used to connect the object.
++
      
++
++
      
++In case of success, a new unconnected UDP object
++returned. In case of error, nil is returned, followed by
++an error message.
++
      
++
++
      
++Note: The TCP object returned will have the option
++"ipv6-v6only" set to true.
++
      
++
++
++
+ 
+ 
+ 
      
+@@ -524,7 +581,7 @@ imperative nature obvious.
+ download ·
+ installation ·
+ introduction ·
+-reference 
++reference
+ 
      
+ 
      
+ 
+diff --git a/etc/dispatch.lua b/etc/dispatch.lua
+index cab7f59..2485415 100644
+--- a/etc/dispatch.lua
++++ b/etc/dispatch.lua
+@@ -5,6 +5,7 @@
+ -----------------------------------------------------------------------------
+ local base = _G
+ local table = require("table")
++local string = require("string")
+ local socket = require("socket")
+ local coroutine = require("coroutine")
+ module("dispatch")
+@@ -43,26 +44,32 @@ end
+ -----------------------------------------------------------------------------
+ -- Mega hack. Don't try to do this at home.
+ -----------------------------------------------------------------------------
+--- we can't yield across calls to protect, so we rewrite it with coxpcall
++-- we can't yield across calls to protect on Lua 5.1, so we rewrite it with
++-- coroutines
+ -- make sure you don't require any module that uses socket.protect before
+ -- loading our hack
+-function socket.protect(f)
+-  return function(...)
+-    local co = coroutine.create(f)
+-    while true do
+-      local results = {coroutine.resume(co, ...)}
+-      local status = table.remove(results, 1)
+-      if not status then
+-        if base.type(results[1]) == 'table' then
+-          return nil, results[1][1]
+-        else base.error(results[1]) end
+-      end
+-      if coroutine.status(co) == "suspended" then
+-        arg = {coroutine.yield(base.unpack(results))}
++if string.sub(base._VERSION, -3) == "5.1" then
++  local function _protect(co, status, ...)
++    if not status then
++      local msg = ...
++      if base.type(msg) == 'table' then
++        return nil, msg[1]
+       else
+-        return base.unpack(results)
++        base.error(msg, 0)
+       end
+     end
++    if coroutine.status(co) == "suspended" then
++      return _protect(co, coroutine.resume(co, coroutine.yield(...)))
++    else
++      return ...
++    end
++  end
++
++  function socket.protect(f)
++    return function(...)
++      local co = coroutine.create(f)
++      return _protect(co, coroutine.resume(co, ...))
++    end
+   end
+ end
+ 
+diff --git a/linux.cmd b/linux.cmd
+index bd59adc..6c6636b 100644
+--- a/linux.cmd
++++ b/linux.cmd
+@@ -1 +1 @@
+-make PLAT=linux DEBUG=DEBUG LUAINC_linux_base=/home/diego/build/linux/include LUAPREFIX_linux=/home/diego/build/linux
++make PLAT=linux DEBUG=DEBUG LUAINC_linux_base=/home/diego/build/ubuntu/include LUAPREFIX_linux=/home/diego/build/ubuntu
+diff --git a/luasocket-scm-0.rockspec b/luasocket-scm-0.rockspec
+index f86567b..352a497 100644
+--- a/luasocket-scm-0.rockspec
++++ b/luasocket-scm-0.rockspec
+@@ -50,13 +50,12 @@ local function make_plat(plat)
+ 	}
+ 	local modules = {
+ 		["socket.core"] = {
+-			sources = { "src/luasocket.c", "src/timeout.c", "src/buffer.c", "src/io.c", "src/auxiliar.c",
+-						"src/options.c", "src/inet.c", "src/except.c", "src/select.c", "src/tcp.c", "src/udp.c" },
++			sources = { "src/luasocket.c", "src/timeout.c", "src/buffer.c", "src/io.c", "src/auxiliar.c", "src/options.c", "src/inet.c", "src/except.c", "src/select.c", "src/tcp.c", "src/udp.c", "src/compat.c" },
+ 			defines = defines[plat],
+ 			incdir = "/src"
+ 		},
+-		["mime.core"] = { 
+-			sources = { "src/mime.c" },
++		["mime.core"] = {
++			sources = { "src/mime.c", "src/compat.c" },
+ 			defines = defines[plat],
+ 			incdir = "/src"
+ 		},
+@@ -73,14 +72,12 @@ local function make_plat(plat)
+ 	if plat == "unix" or plat == "macosx" then
+ 	    modules["socket.core"].sources[#modules["socket.core"].sources+1] = "src/usocket.c"
+ 		modules["socket.unix"] = {
+-		  sources = { "src/buffer.c", "src/auxiliar.c", "src/options.c", "src/timeout.c", "src/io.c", 
+-					  "src/usocket.c", "src/unix.c" },
++		  sources = { "src/buffer.c", "src/auxiliar.c", "src/options.c", "src/timeout.c", "src/io.c", "src/usocket.c", "src/unix.c" },
+ 		  defines = defines[plat],
+ 		  incdir = "/src"
+ 		}
+ 		modules["socket.serial"] = {
+-		  sources = { "src/buffer.c", "src/auxiliar.c", "src/options.c", "src/timeout.c",
+-					  "src/io.c", "src/usocket.c", "src/serial.c" },
++		  sources = { "src/buffer.c", "src/auxiliar.c", "src/options.c", "src/timeout.c", "src/io.c", "src/usocket.c", "src/serial.c" },
+ 		  defines = defines[plat],
+ 		  incdir = "/src"
+ 		}
+diff --git a/makefile b/makefile
+index 04cd894..cc15b4e 100644
+--- a/makefile
++++ b/makefile
+@@ -5,12 +5,12 @@
+ # Targets:
+ #   install            install system independent support
+ #   install-unix           also install unix-only support
+-#   install-both       install for both lua5.1 and lua5.2 
+-#   install-both-unix      also install unix-only 
++#   install-both       install for lua51 lua52 lua53
++#   install-both-unix      also install unix-only
+ #   print	           print the build settings
+ 
+ PLAT?= linux
+-PLATS= macosx linux win32 mingw
++PLATS= macosx linux win32 mingw freebsd solaris
+ 
+ all: $(PLAT)
+ 
+@@ -24,20 +24,26 @@ test:
+ 	lua test/hello.lua
+ 
+ install-both:
+-	$(MAKE) clean 
++	$(MAKE) clean
+ 	@cd src; $(MAKE) $(PLAT) LUAV=5.1
+ 	@cd src; $(MAKE) install LUAV=5.1
+-	$(MAKE) clean 
++	$(MAKE) clean
+ 	@cd src; $(MAKE) $(PLAT) LUAV=5.2
+ 	@cd src; $(MAKE) install LUAV=5.2
++	$(MAKE) clean
++	@cd src; $(MAKE) $(PLAT) LUAV=5.3
++	@cd src; $(MAKE) install LUAV=5.3
+ 
+ install-both-unix:
+-	$(MAKE) clean 
++	$(MAKE) clean
+ 	@cd src; $(MAKE) $(PLAT) LUAV=5.1
+ 	@cd src; $(MAKE) install-unix LUAV=5.1
+-	$(MAKE) clean 
++	$(MAKE) clean
+ 	@cd src; $(MAKE) $(PLAT) LUAV=5.2
+ 	@cd src; $(MAKE) install-unix LUAV=5.2
++	$(MAKE) clean
++	@cd src; $(MAKE) $(PLAT) LUAV=5.3
++	@cd src; $(MAKE) install-unix LUAV=5.3
+ 
+ .PHONY: test
+ 
+diff --git a/src/auxiliar.c b/src/auxiliar.c
+index de625e9..18fa8e4 100644
+--- a/src/auxiliar.c
++++ b/src/auxiliar.c
+@@ -26,7 +26,7 @@ void auxiliar_newclass(lua_State *L, const char *classname, luaL_Reg *func) {
+     luaL_newmetatable(L, classname); /* mt */
+     /* create __index table to place methods */
+     lua_pushstring(L, "__index");    /* mt,"__index" */
+-    lua_newtable(L);                 /* mt,"__index",it */ 
++    lua_newtable(L);                 /* mt,"__index",it */
+     /* put class name into class metatable */
+     lua_pushstring(L, "class");      /* mt,"__index",it,"class" */
+     lua_pushstring(L, classname);    /* mt,"__index",it,"class",classname */
+@@ -84,7 +84,7 @@ int auxiliar_checkboolean(lua_State *L, int objidx) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Return userdata pointer if object belongs to a given class, abort with 
++* Return userdata pointer if object belongs to a given class, abort with
+ * error otherwise
+ \*-------------------------------------------------------------------------*/
+ void *auxiliar_checkclass(lua_State *L, const char *classname, int objidx) {
+@@ -98,7 +98,7 @@ void *auxiliar_checkclass(lua_State *L, const char *classname, int objidx) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Return userdata pointer if object belongs to a given group, abort with 
++* Return userdata pointer if object belongs to a given group, abort with
+ * error otherwise
+ \*-------------------------------------------------------------------------*/
+ void *auxiliar_checkgroup(lua_State *L, const char *groupname, int objidx) {
+@@ -121,7 +121,7 @@ void auxiliar_setclass(lua_State *L, const char *classname, int objidx) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Get a userdata pointer if object belongs to a given group. Return NULL 
++* Get a userdata pointer if object belongs to a given group. Return NULL
+ * otherwise
+ \*-------------------------------------------------------------------------*/
+ void *auxiliar_getgroupudata(lua_State *L, const char *groupname, int objidx) {
+@@ -139,7 +139,7 @@ void *auxiliar_getgroupudata(lua_State *L, const char *groupname, int objidx) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Get a userdata pointer if object belongs to a given class. Return NULL 
++* Get a userdata pointer if object belongs to a given class. Return NULL
+ * otherwise
+ \*-------------------------------------------------------------------------*/
+ void *auxiliar_getclassudata(lua_State *L, const char *classname, int objidx) {
+@@ -151,7 +151,7 @@ void *auxiliar_getclassudata(lua_State *L, const char *classname, int objidx) {
+ * Used to be part of lauxlib in Lua 5.1, was dropped from 5.2.
+ \*-------------------------------------------------------------------------*/
+ int auxiliar_typeerror (lua_State *L, int narg, const char *tname) {
+-  const char *msg = lua_pushfstring(L, "%s expected, got %s", tname, 
++  const char *msg = lua_pushfstring(L, "%s expected, got %s", tname,
+       luaL_typename(L, narg));
+   return luaL_argerror(L, narg, msg);
+ }
+diff --git a/src/auxiliar.h b/src/auxiliar.h
+index ea99013..65511d4 100644
+--- a/src/auxiliar.h
++++ b/src/auxiliar.h
+@@ -4,12 +4,12 @@
+ * Auxiliar routines for class hierarchy manipulation
+ * LuaSocket toolkit (but completely independent of other LuaSocket modules)
+ *
+-* A LuaSocket class is a name associated with Lua metatables. A LuaSocket 
+-* group is a name associated with a class. A class can belong to any number 
++* A LuaSocket class is a name associated with Lua metatables. A LuaSocket
++* group is a name associated with a class. A class can belong to any number
+ * of groups. This module provides the functionality to:
+ *
+-*   - create new classes 
+-*   - add classes to groups 
++*   - create new classes
++*   - add classes to groups
+ *   - set the class of objects
+ *   - check if an object belongs to a given class or group
+ *   - get the userdata associated to objects
+@@ -26,11 +26,12 @@
+ * "class" with the class name.
+ *
+ * The mapping from class name to the corresponding metatable and the
+-* reverse mapping are done using lauxlib. 
++* reverse mapping are done using lauxlib.
+ \*=========================================================================*/
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
++#include "compat.h"
+ 
+ int auxiliar_open(lua_State *L);
+ void auxiliar_newclass(lua_State *L, const char *classname, luaL_Reg *func);
+diff --git a/src/buffer.c b/src/buffer.c
+index 4ef4e8e..fff1634 100644
+--- a/src/buffer.c
++++ b/src/buffer.c
+@@ -4,6 +4,7 @@
+ \*=========================================================================*/
+ #include "lua.h"
+ #include "lauxlib.h"
++#include "compat.h"
+ 
+ #include "buffer.h"
+ 
+@@ -37,7 +38,7 @@ int buffer_open(lua_State *L) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Initializes C structure 
++* Initializes C structure
+ \*-------------------------------------------------------------------------*/
+ void buffer_init(p_buffer buf, p_io io, p_timeout tm) {
+     buf->first = buf->last = 0;
+@@ -61,8 +62,8 @@ int buffer_meth_getstats(lua_State *L, p_buffer buf) {
+ * object:setstats() interface
+ \*-------------------------------------------------------------------------*/
+ int buffer_meth_setstats(lua_State *L, p_buffer buf) {
+-    buf->received = (long) luaL_optnumber(L, 2, (lua_Number) buf->received); 
+-    buf->sent = (long) luaL_optnumber(L, 3, (lua_Number) buf->sent); 
++    buf->received = (long) luaL_optnumber(L, 2, (lua_Number) buf->received);
++    buf->sent = (long) luaL_optnumber(L, 3, (lua_Number) buf->sent);
+     if (lua_isnumber(L, 4)) buf->birthday = timeout_gettime() - lua_tonumber(L, 4);
+     lua_pushnumber(L, 1);
+     return 1;
+@@ -78,9 +79,7 @@ int buffer_meth_send(lua_State *L, p_buffer buf) {
+     const char *data = luaL_checklstring(L, 2, &size);
+     long start = (long) luaL_optnumber(L, 3, 1);
+     long end = (long) luaL_optnumber(L, 4, -1);
+-#ifdef LUASOCKET_DEBUG
+-    p_timeout tm = timeout_markstart(buf->tm);
+-#endif
++    timeout_markstart(buf->tm);
+     if (start < 0) start = (long) (size+start+1);
+     if (end < 0) end = (long) (size+end+1);
+     if (start < 1) start = (long) 1;
+@@ -89,7 +88,7 @@ int buffer_meth_send(lua_State *L, p_buffer buf) {
+     /* check if there was an error */
+     if (err != IO_DONE) {
+         lua_pushnil(L);
+-        lua_pushstring(L, buf->io->error(buf->io->ctx, err)); 
++        lua_pushstring(L, buf->io->error(buf->io->ctx, err));
+         lua_pushnumber(L, (lua_Number) (sent+start-1));
+     } else {
+         lua_pushnumber(L, (lua_Number) (sent+start-1));
+@@ -98,7 +97,7 @@ int buffer_meth_send(lua_State *L, p_buffer buf) {
+     }
+ #ifdef LUASOCKET_DEBUG
+     /* push time elapsed during operation as the last return value */
+-    lua_pushnumber(L, timeout_gettime() - timeout_getstart(tm));
++    lua_pushnumber(L, timeout_gettime() - timeout_getstart(buf->tm));
+ #endif
+     return lua_gettop(L) - top;
+ }
+@@ -111,10 +110,8 @@ int buffer_meth_receive(lua_State *L, p_buffer buf) {
+     luaL_Buffer b;
+     size_t size;
+     const char *part = luaL_optlstring(L, 3, "", &size);
+-#ifdef LUASOCKET_DEBUG
+-    p_timeout tm = timeout_markstart(buf->tm);
+-#endif
+-    /* initialize buffer with optional extra prefix 
++    timeout_markstart(buf->tm);
++    /* initialize buffer with optional extra prefix
+      * (useful for concatenating previous partial results) */
+     luaL_buffinit(L, &b);
+     luaL_addlstring(&b, part, size);
+@@ -122,12 +119,12 @@ int buffer_meth_receive(lua_State *L, p_buffer buf) {
+     if (!lua_isnumber(L, 2)) {
+         const char *p= luaL_optstring(L, 2, "*l");
+         if (p[0] == '*' && p[1] == 'l') err = recvline(buf, &b);
+-        else if (p[0] == '*' && p[1] == 'a') err = recvall(buf, &b); 
++        else if (p[0] == '*' && p[1] == 'a') err = recvall(buf, &b);
+         else luaL_argcheck(L, 0, 2, "invalid receive pattern");
+-    /* get a fixed number of bytes (minus what was already partially 
++    /* get a fixed number of bytes (minus what was already partially
+      * received) */
+     } else {
+-        double n = lua_tonumber(L, 2); 
++        double n = lua_tonumber(L, 2);
+         size_t wanted = (size_t) n;
+         luaL_argcheck(L, n >= 0, 2, "invalid receive pattern");
+         if (size == 0 || wanted > size)
+@@ -138,8 +135,8 @@ int buffer_meth_receive(lua_State *L, p_buffer buf) {
+         /* we can't push anyting in the stack before pushing the
+          * contents of the buffer. this is the reason for the complication */
+         luaL_pushresult(&b);
+-        lua_pushstring(L, buf->io->error(buf->io->ctx, err)); 
+-        lua_pushvalue(L, -2); 
++        lua_pushstring(L, buf->io->error(buf->io->ctx, err));
++        lua_pushvalue(L, -2);
+         lua_pushnil(L);
+         lua_replace(L, -4);
+     } else {
+@@ -149,7 +146,7 @@ int buffer_meth_receive(lua_State *L, p_buffer buf) {
+     }
+ #ifdef LUASOCKET_DEBUG
+     /* push time elapsed during operation as the last return value */
+-    lua_pushnumber(L, timeout_gettime() - timeout_getstart(tm));
++    lua_pushnumber(L, timeout_gettime() - timeout_getstart(buf->tm));
+ #endif
+     return lua_gettop(L) - top;
+ }
+@@ -222,7 +219,7 @@ static int recvall(p_buffer buf, luaL_Buffer *b) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Reads a line terminated by a CR LF pair or just by a LF. The CR and LF 
++* Reads a line terminated by a CR LF pair or just by a LF. The CR and LF
+ * are not returned by the function and are discarded from the buffer
+ \*-------------------------------------------------------------------------*/
+ static int recvline(p_buffer buf, luaL_Buffer *b) {
+@@ -252,7 +249,7 @@ static int recvline(p_buffer buf, luaL_Buffer *b) {
+ static void buffer_skip(p_buffer buf, size_t count) {
+     buf->received += count;
+     buf->first += count;
+-    if (buffer_isempty(buf)) 
++    if (buffer_isempty(buf))
+         buf->first = buf->last = 0;
+ }
+ 
+diff --git a/src/compat.c b/src/compat.c
+new file mode 100644
+index 0000000..c2d99cb
+--- /dev/null
++++ b/src/compat.c
+@@ -0,0 +1,19 @@
++#include "compat.h"
++
++#if LUA_VERSION_NUM==501
++/*
++** Adapted from Lua 5.2
++*/
++void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
++  luaL_checkstack(L, nup+1, "too many upvalues");
++  for (; l->name != NULL; l++) {  /* fill the table with given functions */
++    int i;
++    lua_pushstring(L, l->name);
++    for (i = 0; i < nup; i++)  /* copy upvalues to the top */
++      lua_pushvalue(L, -(nup+1));
++    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
++    lua_settable(L, -(nup + 3));
++  }
++  lua_pop(L, nup);  /* remove upvalues */
++}
++#endif
+diff --git a/src/compat.h b/src/compat.h
+new file mode 100644
+index 0000000..7bf8010
+--- /dev/null
++++ b/src/compat.h
+@@ -0,0 +1,11 @@
++#ifndef COMPAT_H
++#define COMPAT_H
++
++#include "lua.h"
++#include "lauxlib.h"
++
++#if LUA_VERSION_NUM==501
++void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);
++#endif
++
++#endif
+diff --git a/src/except.c b/src/except.c
+index 002e701..60b5005 100644
+--- a/src/except.c
++++ b/src/except.c
+@@ -6,9 +6,19 @@
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
++#include "compat.h"
+ 
+ #include "except.h"
+ 
++#if LUA_VERSION_NUM < 502
++#define lua_pcallk(L, na, nr, err, ctx, cont) \
++    (((void)ctx),((void)cont),lua_pcall(L, na, nr, err))
++#endif
++
++#if LUA_VERSION_NUM < 503
++typedef int lua_KContext;
++#endif
++
+ /*=========================================================================*\
+ * Internal function prototypes.
+ \*=========================================================================*/
+@@ -29,18 +39,17 @@ static luaL_Reg func[] = {
+ * Try factory
+ \*-------------------------------------------------------------------------*/
+ static void wrap(lua_State *L) {
+-    lua_newtable(L);
+-    lua_pushnumber(L, 1);
+-    lua_pushvalue(L, -3);
+-    lua_settable(L, -3);
+-    lua_insert(L, -2);
+-    lua_pop(L, 1);
++    lua_createtable(L, 1, 0);
++    lua_pushvalue(L, -2);
++    lua_rawseti(L, -2, 1);
++    lua_pushvalue(L, lua_upvalueindex(1));
++    lua_setmetatable(L, -2);
+ }
+ 
+ static int finalize(lua_State *L) {
+     if (!lua_toboolean(L, 1)) {
+-        lua_pushvalue(L, lua_upvalueindex(1));
+-        lua_pcall(L, 0, 0, 0);
++        lua_pushvalue(L, lua_upvalueindex(2));
++        lua_call(L, 0, 0);
+         lua_settop(L, 2);
+         wrap(L);
+         lua_error(L);
+@@ -48,15 +57,17 @@ static int finalize(lua_State *L) {
+     } else return lua_gettop(L);
+ }
+ 
+-static int do_nothing(lua_State *L) { 
++static int do_nothing(lua_State *L) {
+     (void) L;
+-    return 0; 
++    return 0;
+ }
+ 
+ static int global_newtry(lua_State *L) {
+     lua_settop(L, 1);
+     if (lua_isnil(L, 1)) lua_pushcfunction(L, do_nothing);
+-    lua_pushcclosure(L, finalize, 1);
++    lua_pushvalue(L, lua_upvalueindex(1));
++    lua_insert(L, -2);
++    lua_pushcclosure(L, finalize, 2);
+     return 1;
+ }
+ 
+@@ -64,27 +75,49 @@ static int global_newtry(lua_State *L) {
+ * Protect factory
+ \*-------------------------------------------------------------------------*/
+ static int unwrap(lua_State *L) {
+-    if (lua_istable(L, -1)) {
+-        lua_pushnumber(L, 1);
+-        lua_gettable(L, -2);
+-        lua_pushnil(L);
+-        lua_insert(L, -2);
+-        return 1;
+-    } else return 0;
++    if (lua_istable(L, -1) && lua_getmetatable(L, -1)) {
++        int r = lua_rawequal(L, -1, lua_upvalueindex(1));
++        lua_pop(L, 1);
++        if (r) {
++            lua_pushnil(L);
++            lua_rawgeti(L, -2, 1);
++            return 1;
++        }
++    }
++    return 0;
+ }
+ 
+-static int protected_(lua_State *L) {
+-    lua_pushvalue(L, lua_upvalueindex(1));
+-    lua_insert(L, 1);
+-    if (lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0) != 0) {
++static int protected_finish(lua_State *L, int status, lua_KContext ctx) {
++    (void)ctx;
++    if (status != 0 && status != LUA_YIELD) {
+         if (unwrap(L)) return 2;
+-        else lua_error(L);
+-        return 0;
++        else return lua_error(L);
+     } else return lua_gettop(L);
+ }
+ 
++#if LUA_VERSION_NUM == 502
++static int protected_cont(lua_State *L) {
++    int ctx = 0;
++    int status = lua_getctx(L, &ctx);
++    return protected_finish(L, status, ctx);
++}
++#else
++#define protected_cont protected_finish
++#endif
++
++static int protected_(lua_State *L) {
++    int status;
++    lua_pushvalue(L, lua_upvalueindex(2));
++    lua_insert(L, 1);
++    status = lua_pcallk(L, lua_gettop(L) - 1, LUA_MULTRET, 0, 0, protected_cont);
++    return protected_finish(L, status, 0);
++}
++
+ static int global_protect(lua_State *L) {
+-    lua_pushcclosure(L, protected_, 1);
++    lua_settop(L, 1);
++    lua_pushvalue(L, lua_upvalueindex(1));
++    lua_insert(L, 1);
++    lua_pushcclosure(L, protected_, 2);
+     return 1;
+ }
+ 
+@@ -92,10 +125,9 @@ static int global_protect(lua_State *L) {
+ * Init module
+ \*-------------------------------------------------------------------------*/
+ int except_open(lua_State *L) {
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+-    luaL_setfuncs(L, func, 0);
+-#else
+-    luaL_openlib(L, NULL, func, 0);
+-#endif
++    lua_newtable(L); /* metatable for wrapped exceptions */
++    lua_pushboolean(L, 0);
++    lua_setfield(L, -2, "__metatable");
++    luaL_setfuncs(L, func, 1);
+     return 0;
+ }
+diff --git a/src/except.h b/src/except.h
+index 1e7a245..2497c05 100644
+--- a/src/except.h
++++ b/src/except.h
+@@ -9,21 +9,26 @@
+ * error checking was taking a substantial amount of the coding. These
+ * function greatly simplify the task of checking errors.
+ *
+-* The main idea is that functions should return nil as its first return
+-* value when it finds an error, and return an error message (or value)
++* The main idea is that functions should return nil as their first return
++* values when they find an error, and return an error message (or value)
+ * following nil. In case of success, as long as the first value is not nil,
+ * the other values don't matter.
+ *
+ * The idea is to nest function calls with the "try" function. This function
+-* checks the first value, and calls "error" on the second if the first is
+-* nil. Otherwise, it returns all values it received. 
++* checks the first value, and, if it's falsy, wraps the second value in a
++* table with metatable and calls "error" on it. Otherwise, it returns all
++* values it received. Basically, it works like the Lua "assert" function,
++* but it creates errors targeted specifically at "protect".
+ *
+-* The protect function returns a new function that behaves exactly like the
+-* function it receives, but the new function doesn't throw exceptions: it
+-* returns nil followed by the error message instead.
++* The "newtry" function is a factory for "try" functions that call a
++* finalizer in protected mode before calling "error".
+ *
+-* With these two function, it's easy to write functions that throw
+-* exceptions on error, but that don't interrupt the user script. 
++* The "protect" function returns a new function that behaves exactly like
++* the function it receives, but the new function catches exceptions thrown
++* by "try" functions and returns nil followed by the error message instead.
++*
++* With these three functions, it's easy to write functions that throw
++* exceptions on error, but that don't interrupt the user script.
+ \*=========================================================================*/
+ 
+ #include "lua.h"
+diff --git a/src/ftp.lua b/src/ftp.lua
+index ea1145b..e0c3cae 100644
+--- a/src/ftp.lua
++++ b/src/ftp.lua
+@@ -268,11 +268,20 @@ _M.command = socket.protect(function(cmdt)
+     cmdt = override(cmdt)
+     socket.try(cmdt.host, "missing hostname")
+     socket.try(cmdt.command, "missing command")
+-    local f = open(cmdt.host, cmdt.port, cmdt.create)
++    local f = _M.open(cmdt.host, cmdt.port, cmdt.create)
+     f:greet()
+     f:login(cmdt.user, cmdt.password)
+-    f.try(f.tp:command(cmdt.command, cmdt.argument))
+-    if cmdt.check then f.try(f.tp:check(cmdt.check)) end
++    if type(cmdt.command) == "table" then
++        local argument = cmdt.argument or {}
++        local check = cmdt.check or {}
++        for i,cmd in ipairs(cmdt.command) do
++            f.try(f.tp:command(cmd, argument[i]))
++            if check[i] then f.try(f.tp:check(check[i])) end
++        end
++    else
++        f.try(f.tp:command(cmdt.command, cmdt.argument))
++        if cmdt.check then f.try(f.tp:check(cmdt.check)) end
++    end
+     f:quit()
+     return f:close()
+ end)
+@@ -282,4 +291,4 @@ _M.get = socket.protect(function(gett)
+     else return tget(gett) end
+ end)
+ 
+-return _M
+\ No newline at end of file
++return _M
+diff --git a/src/http.lua b/src/http.lua
+index ac4b2d6..d6bcc91 100644
+--- a/src/http.lua
++++ b/src/http.lua
+@@ -22,12 +22,15 @@ local _M = socket.http
+ -- Program constants
+ -----------------------------------------------------------------------------
+ -- connection timeout in seconds
+-TIMEOUT = 60
+--- default port for document retrieval
+-_M.PORT = 80
++_M.TIMEOUT = 60
+ -- user agent field sent in request
+ _M.USERAGENT = socket._VERSION
+ 
++-- supported schemes
++local SCHEMES = { ["http"] = true }
++-- default port for document retrieval
++local PORT = 80
++
+ -----------------------------------------------------------------------------
+ -- Reads MIME headers from a connection, unfolding where needed
+ -----------------------------------------------------------------------------
+@@ -114,7 +117,7 @@ function _M.open(host, port, create)
+     h.try = socket.newtry(function() h:close() end)
+     -- set timeout before connecting
+     h.try(c:settimeout(_M.TIMEOUT))
+-    h.try(c:connect(host, port or _M.PORT))
++    h.try(c:connect(host, port or PORT))
+     -- here everything worked
+     return h
+ end
+@@ -186,7 +189,7 @@ end
+ local function adjusturi(reqt)
+     local u = reqt
+     -- if there is a proxy, we need the full url. otherwise, just a part.
+-    if not reqt.proxy and not PROXY then
++    if not reqt.proxy and not _M.PROXY then
+         u = {
+            path = socket.try(reqt.path, "invalid path 'nil'"),
+            params = reqt.params,
+@@ -198,7 +201,7 @@ local function adjusturi(reqt)
+ end
+ 
+ local function adjustproxy(reqt)
+-    local proxy = reqt.proxy or PROXY
++    local proxy = reqt.proxy or _M.PROXY
+     if proxy then
+         proxy = url.parse(proxy)
+         return proxy.host, proxy.port or 3128
+@@ -209,17 +212,27 @@ end
+ 
+ local function adjustheaders(reqt)
+     -- default headers
++    local host = string.gsub(reqt.authority, "^.-@", "")
+     local lower = {
+         ["user-agent"] = _M.USERAGENT,
+-        ["host"] = reqt.host,
++        ["host"] = host,
+         ["connection"] = "close, TE",
+         ["te"] = "trailers"
+     }
+     -- if we have authentication information, pass it along
+     if reqt.user and reqt.password then
+-        lower["authorization"] = 
++        lower["authorization"] =
+             "Basic " ..  (mime.b64(reqt.user .. ":" .. reqt.password))
+     end
++    -- if we have proxy authentication information, pass it along
++    local proxy = reqt.proxy or _M.PROXY
++    if proxy then
++        proxy = url.parse(proxy)
++        if proxy.user and proxy.password then
++            lower["proxy-authorization"] =
++                "Basic " ..  (mime.b64(proxy.user .. ":" .. proxy.password))
++        end
++    end
+     -- override with user headers
+     for i,v in base.pairs(reqt.headers or lower) do
+         lower[string.lower(i)] = v
+@@ -230,7 +243,7 @@ end
+ -- default url parts
+ local default = {
+     host = "",
+-    port = _M.PORT,
++    port = PORT,
+     path ="/",
+     scheme = "http"
+ }
+@@ -240,22 +253,27 @@ local function adjustrequest(reqt)
+     local nreqt = reqt.url and url.parse(reqt.url, default) or {}
+     -- explicit components override url
+     for i,v in base.pairs(reqt) do nreqt[i] = v end
+-    if nreqt.port == "" then nreqt.port = 80 end
+-    socket.try(nreqt.host and nreqt.host ~= "", 
+-        "invalid host '" .. base.tostring(nreqt.host) .. "'")
++    if nreqt.port == "" then nreqt.port = PORT end
++    if not (nreqt.host and nreqt.host ~= "") then
++        socket.try(nil, "invalid host '" .. base.tostring(nreqt.host) .. "'")
++    end
+     -- compute uri if user hasn't overriden
+     nreqt.uri = reqt.uri or adjusturi(nreqt)
+-    -- ajust host and port if there is a proxy
+-    nreqt.host, nreqt.port = adjustproxy(nreqt)
+     -- adjust headers in request
+     nreqt.headers = adjustheaders(nreqt)
++    -- ajust host and port if there is a proxy
++    nreqt.host, nreqt.port = adjustproxy(nreqt)
+     return nreqt
+ end
+ 
+ local function shouldredirect(reqt, code, headers)
+-    return headers.location and
+-           string.gsub(headers.location, "%s", "") ~= "" and
+-           (reqt.redirect ~= false) and
++    local location = headers.location
++    if not location then return false end
++    location = string.gsub(location, "%s", "")
++    if location == "" then return false end
++    local scheme = string.match(location, "^([%w][%w%+%-%.]*)%:")
++    if scheme and not SCHEMES[scheme] then return false end
++    return (reqt.redirect ~= false) and
+            (code == 301 or code == 302 or code == 303 or code == 307) and
+            (not reqt.method or reqt.method == "GET" or reqt.method == "HEAD")
+            and (not reqt.nredirects or reqt.nredirects < 5)
+@@ -279,10 +297,10 @@ local trequest, tredirect
+         source = reqt.source,
+         sink = reqt.sink,
+         headers = reqt.headers,
+-        proxy = reqt.proxy, 
++        proxy = reqt.proxy,
+         nredirects = (reqt.nredirects or 0) + 1,
+         create = reqt.create
+-    }   
++    }
+     -- pass location header back as a hint we redirected
+     headers = headers or {}
+     headers.location = headers.location or location
+@@ -299,7 +317,7 @@ end
+     h:sendheaders(nreqt.headers)
+     -- if there is a body, send it
+     if nreqt.source then
+-        h:sendbody(nreqt.headers, nreqt.source, nreqt.step) 
++        h:sendbody(nreqt.headers, nreqt.source, nreqt.step)
+     end
+     local code, status = h:receivestatusline()
+     -- if it is an HTTP/0.9 server, simply get the body and we are done
+@@ -309,13 +327,13 @@ end
+     end
+     local headers
+     -- ignore any 100-continue messages
+-    while code == 100 do 
++    while code == 100 do
+         headers = h:receiveheaders()
+         code, status = h:receivestatusline()
+     end
+     headers = h:receiveheaders()
+     -- at this point we should have a honest reply from the server
+-    -- we can't redirect if we already used the source, so we report the error 
++    -- we can't redirect if we already used the source, so we report the error
+     if shouldredirect(nreqt, code, headers) and not nreqt.source then
+         h:close()
+         return tredirect(reqt, headers.location)
+@@ -351,4 +369,4 @@ _M.request = socket.protect(function(reqt, body)
+     else return trequest(reqt) end
+ end)
+ 
+-return _M
+\ No newline at end of file
++return _M
+diff --git a/src/inet.c b/src/inet.c
+index 1a411f6..f4c8404 100644
+--- a/src/inet.c
++++ b/src/inet.c
+@@ -8,6 +8,7 @@
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
++#include "compat.h"
+ 
+ #include "inet.h"
+ 
+@@ -41,11 +42,7 @@ int inet_open(lua_State *L)
+ {
+     lua_pushstring(L, "dns");
+     lua_newtable(L);
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+     luaL_setfuncs(L, func, 0);
+-#else
+-    luaL_openlib(L, NULL, func, 0);
+-#endif
+     lua_settable(L, -3);
+     return 0;
+ }
+@@ -97,7 +94,7 @@ static int inet_global_getnameinfo(lua_State *L) {
+ 
+     memset(&hints, 0, sizeof(hints));
+     hints.ai_socktype = SOCK_STREAM;
+-    hints.ai_family = PF_UNSPEC;
++    hints.ai_family = AF_UNSPEC;
+ 
+     ret = getaddrinfo(host, serv, &hints, &resolved);
+     if (ret != 0) {
+@@ -108,8 +105,8 @@ static int inet_global_getnameinfo(lua_State *L) {
+ 
+     lua_newtable(L);
+     for (i = 1, iter = resolved; iter; i++, iter = iter->ai_next) {
+-        getnameinfo(iter->ai_addr, (socklen_t) iter->ai_addrlen, 
+-            hbuf, host? (socklen_t) sizeof(hbuf): 0, 
++        getnameinfo(iter->ai_addr, (socklen_t) iter->ai_addrlen,
++            hbuf, host? (socklen_t) sizeof(hbuf): 0,
+             sbuf, serv? (socklen_t) sizeof(sbuf): 0, 0);
+         if (host) {
+             lua_pushnumber(L, i);
+@@ -149,7 +146,7 @@ static int inet_global_toip(lua_State *L)
+ int inet_optfamily(lua_State* L, int narg, const char* def)
+ {
+     static const char* optname[] = { "unspec", "inet", "inet6", NULL };
+-    static int optvalue[] = { PF_UNSPEC, PF_INET, PF_INET6, 0 };
++    static int optvalue[] = { AF_UNSPEC, AF_INET, AF_INET6, 0 };
+ 
+     return optvalue[luaL_checkoption(L, narg, def, optname)];
+ }
+@@ -170,7 +167,7 @@ static int inet_global_getaddrinfo(lua_State *L)
+     int i = 1, ret = 0;
+     memset(&hints, 0, sizeof(hints));
+     hints.ai_socktype = SOCK_STREAM;
+-    hints.ai_family = PF_UNSPEC;
++    hints.ai_family = AF_UNSPEC;
+     ret = getaddrinfo(hostname, NULL, &hints, &resolved);
+     if (ret != 0) {
+         lua_pushnil(L);
+@@ -180,9 +177,10 @@ static int inet_global_getaddrinfo(lua_State *L)
+     lua_newtable(L);
+     for (iterator = resolved; iterator; iterator = iterator->ai_next) {
+         char hbuf[NI_MAXHOST];
+-        ret = getnameinfo(iterator->ai_addr, (socklen_t) iterator->ai_addrlen, 
++        ret = getnameinfo(iterator->ai_addr, (socklen_t) iterator->ai_addrlen,
+             hbuf, (socklen_t) sizeof(hbuf), NULL, 0, NI_NUMERICHOST);
+         if (ret){
++          freeaddrinfo(resolved);
+           lua_pushnil(L);
+           lua_pushstring(L, socket_gaistrerror(ret));
+           return 2;
+@@ -200,6 +198,16 @@ static int inet_global_getaddrinfo(lua_State *L)
+                 lua_pushliteral(L, "inet6");
+                 lua_settable(L, -3);
+                 break;
++            case AF_UNSPEC:
++                lua_pushliteral(L, "family");
++                lua_pushliteral(L, "unspec");
++                lua_settable(L, -3);
++                break;
++            default:
++                lua_pushliteral(L, "family");
++                lua_pushliteral(L, "unknown");
++                lua_settable(L, -3);
++                break;
+         }
+         lua_pushliteral(L, "addr");
+         lua_pushstring(L, hbuf);
+@@ -256,12 +264,11 @@ int inet_meth_getpeername(lua_State *L, p_socket ps, int family)
+     }
+     lua_pushstring(L, name);
+     lua_pushinteger(L, (int) strtol(port, (char **) NULL, 10));
+-    if (family == PF_INET) {
+-        lua_pushliteral(L, "inet");
+-    } else if (family == PF_INET6) {
+-        lua_pushliteral(L, "inet6");
+-    } else {
+-        lua_pushliteral(L, "uknown family");
++    switch (family) {
++        case AF_INET: lua_pushliteral(L, "inet"); break;
++        case AF_INET6: lua_pushliteral(L, "inet6"); break;
++        case AF_UNSPEC: lua_pushliteral(L, "unspec"); break;
++        default: lua_pushliteral(L, "unknown"); break;
+     }
+     return 3;
+ }
+@@ -281,7 +288,7 @@ int inet_meth_getsockname(lua_State *L, p_socket ps, int family)
+         lua_pushstring(L, socket_strerror(errno));
+         return 2;
+     }
+-	err=getnameinfo((struct sockaddr *)&peer, peer_len, 
++	err=getnameinfo((struct sockaddr *)&peer, peer_len,
+ 		name, INET6_ADDRSTRLEN, port, 6, NI_NUMERICHOST | NI_NUMERICSERV);
+     if (err) {
+         lua_pushnil(L);
+@@ -290,12 +297,11 @@ int inet_meth_getsockname(lua_State *L, p_socket ps, int family)
+     }
+     lua_pushstring(L, name);
+     lua_pushstring(L, port);
+-    if (family == PF_INET) {
+-        lua_pushliteral(L, "inet");
+-    } else if (family == PF_INET6) {
+-        lua_pushliteral(L, "inet6");
+-    } else {
+-        lua_pushliteral(L, "uknown family");
++    switch (family) {
++        case AF_INET: lua_pushliteral(L, "inet"); break;
++        case AF_INET6: lua_pushliteral(L, "inet6"); break;
++        case AF_UNSPEC: lua_pushliteral(L, "unspec"); break;
++        default: lua_pushliteral(L, "unknown"); break;
+     }
+     return 3;
+ }
+@@ -346,8 +352,13 @@ static void inet_pushresolved(lua_State *L, struct hostent *hp)
+ /*-------------------------------------------------------------------------*\
+ * Tries to create a new inet socket
+ \*-------------------------------------------------------------------------*/
+-const char *inet_trycreate(p_socket ps, int family, int type) {
+-    return socket_strerror(socket_create(ps, family, type, 0));
++const char *inet_trycreate(p_socket ps, int family, int type, int protocol) {
++    const char *err = socket_strerror(socket_create(ps, family, type, protocol));
++    if (err == NULL && family == AF_INET6) {
++        int yes = 1;
++        setsockopt(*ps, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&yes, sizeof(yes));
++    }
++    return err;
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+@@ -356,21 +367,21 @@ const char *inet_trycreate(p_socket ps, int family, int type) {
+ const char *inet_trydisconnect(p_socket ps, int family, p_timeout tm)
+ {
+     switch (family) {
+-        case PF_INET: {
++        case AF_INET: {
+             struct sockaddr_in sin;
+             memset((char *) &sin, 0, sizeof(sin));
+             sin.sin_family = AF_UNSPEC;
+             sin.sin_addr.s_addr = INADDR_ANY;
+-            return socket_strerror(socket_connect(ps, (SA *) &sin, 
++            return socket_strerror(socket_connect(ps, (SA *) &sin,
+                 sizeof(sin), tm));
+         }
+-        case PF_INET6: {
++        case AF_INET6: {
+             struct sockaddr_in6 sin6;
+-            struct in6_addr addrany = IN6ADDR_ANY_INIT; 
++            struct in6_addr addrany = IN6ADDR_ANY_INIT;
+             memset((char *) &sin6, 0, sizeof(sin6));
+             sin6.sin6_family = AF_UNSPEC;
+             sin6.sin6_addr = addrany;
+-            return socket_strerror(socket_connect(ps, (SA *) &sin6, 
++            return socket_strerror(socket_connect(ps, (SA *) &sin6,
+                 sizeof(sin6), tm));
+         }
+     }
+@@ -385,6 +396,7 @@ const char *inet_tryconnect(p_socket ps, int *family, const char *address,
+ {
+     struct addrinfo *iterator = NULL, *resolved = NULL;
+     const char *err = NULL;
++    int current_family = *family;
+     /* try resolving */
+     err = socket_gaistrerror(getaddrinfo(address, serv,
+                 connecthints, &resolved));
+@@ -399,23 +411,23 @@ const char *inet_tryconnect(p_socket ps, int *family, const char *address,
+          * that shows up while iterating. if there was a
+          * bind, all families will be the same and we will
+          * not enter this branch. */
+-        if (*family != iterator->ai_family) {
++        if (current_family != iterator->ai_family || *ps == SOCKET_INVALID) {
+             socket_destroy(ps);
+-            err = socket_strerror(socket_create(ps, iterator->ai_family, 
+-                iterator->ai_socktype, iterator->ai_protocol));
+-            if (err != NULL) {
+-                freeaddrinfo(resolved);
+-                return err;
+-            }
+-            *family = iterator->ai_family;
+-            /* all sockets initially non-blocking */
++            err = inet_trycreate(ps, iterator->ai_family,
++                iterator->ai_socktype, iterator->ai_protocol);
++            if (err) continue;
++            current_family = iterator->ai_family;
++            /* set non-blocking before connect */
+             socket_setnonblocking(ps);
+         }
+         /* try connecting to remote address */
+-        err = socket_strerror(socket_connect(ps, (SA *) iterator->ai_addr, 
++        err = socket_strerror(socket_connect(ps, (SA *) iterator->ai_addr,
+             (socklen_t) iterator->ai_addrlen, tm));
+-        /* if success, break out of loop */
+-        if (err == NULL) break;
++        /* if success or timeout is zero, break out of loop */
++        if (err == NULL || timeout_iszero(tm)) {
++            *family = current_family;
++            break;
++        }
+     }
+     freeaddrinfo(resolved);
+     /* here, if err is set, we failed */
+@@ -425,29 +437,27 @@ const char *inet_tryconnect(p_socket ps, int *family, const char *address,
+ /*-------------------------------------------------------------------------*\
+ * Tries to accept a socket
+ \*-------------------------------------------------------------------------*/
+-const char *inet_tryaccept(p_socket server, int family, p_socket client, 
+-    p_timeout tm)
+-{
++const char *inet_tryaccept(p_socket server, int family, p_socket client,
++    p_timeout tm) {
+ 	socklen_t len;
+ 	t_sockaddr_storage addr;
+-	if (family == PF_INET6) {
+-		len = sizeof(struct sockaddr_in6);
+-	} else {
+-		len = sizeof(struct sockaddr_in);
+-	}
+-	return socket_strerror(socket_accept(server, client, (SA *) &addr, 
++    switch (family) {
++        case AF_INET6: len = sizeof(struct sockaddr_in6); break;
++        case AF_INET: len = sizeof(struct sockaddr_in); break;
++        default: len = sizeof(addr); break;
++    }
++	return socket_strerror(socket_accept(server, client, (SA *) &addr,
+         &len, tm));
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+ * Tries to bind socket to (address, port)
+ \*-------------------------------------------------------------------------*/
+-const char *inet_trybind(p_socket ps, const char *address, const char *serv,
+-        struct addrinfo *bindhints)
+-{
++const char *inet_trybind(p_socket ps, int *family, const char *address,
++    const char *serv, struct addrinfo *bindhints) {
+     struct addrinfo *iterator = NULL, *resolved = NULL;
+     const char *err = NULL;
+-    t_socket sock = *ps;
++    int current_family = *family;
+     /* translate luasocket special values to C */
+     if (strcmp(address, "*") == 0) address = NULL;
+     if (!serv) serv = "0";
+@@ -459,35 +469,32 @@ const char *inet_trybind(p_socket ps, const char *address, const char *serv,
+     }
+     /* iterate over resolved addresses until one is good */
+     for (iterator = resolved; iterator; iterator = iterator->ai_next) {
+-        if(sock == SOCKET_INVALID) {
+-            err = socket_strerror(socket_create(&sock, iterator->ai_family,
+-                        iterator->ai_socktype, iterator->ai_protocol));
+-            if(err)
+-                continue;
++        if (current_family != iterator->ai_family || *ps == SOCKET_INVALID) {
++            socket_destroy(ps);
++            err = inet_trycreate(ps, iterator->ai_family,
++                        iterator->ai_socktype, iterator->ai_protocol);
++            if (err) continue;
++            current_family = iterator->ai_family;
+         }
+         /* try binding to local address */
+-        err = socket_strerror(socket_bind(&sock,
+-            (SA *) iterator->ai_addr,
++        err = socket_strerror(socket_bind(ps, (SA *) iterator->ai_addr,
+             (socklen_t) iterator->ai_addrlen));
+-
+         /* keep trying unless bind succeeded */
+-        if (err) {
+-            if(sock != *ps)
+-                socket_destroy(&sock);
+-        } else {
+-            /* remember what we connected to, particularly the family */
+-            *bindhints = *iterator;
++        if (err == NULL) {
++            *family = current_family;
++            /* set to non-blocking after bind */
++            socket_setnonblocking(ps);
+             break;
+         }
+     }
+     /* cleanup and return error */
+     freeaddrinfo(resolved);
+-    *ps = sock;
++    /* here, if err is set, we failed */
+     return err;
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Some systems do not provide these so that we provide our own. 
++* Some systems do not provide these so that we provide our own.
+ \*-------------------------------------------------------------------------*/
+ #ifdef LUASOCKET_INET_ATON
+ int inet_aton(const char *cp, struct in_addr *inp)
+@@ -512,7 +519,7 @@ int inet_aton(const char *cp, struct in_addr *inp)
+ #endif
+ 
+ #ifdef LUASOCKET_INET_PTON
+-int inet_pton(int af, const char *src, void *dst) 
++int inet_pton(int af, const char *src, void *dst)
+ {
+     struct addrinfo hints, *res;
+     int ret = 1;
+@@ -529,7 +536,7 @@ int inet_pton(int af, const char *src, void *dst)
+     } else {
+         ret = -1;
+     }
+-    freeaddrinfo(res); 
++    freeaddrinfo(res);
+     return ret;
+ }
+ 
+diff --git a/src/inet.h b/src/inet.h
+index 1f1a96a..feb3541 100644
+--- a/src/inet.h
++++ b/src/inet.h
+@@ -1,12 +1,12 @@
+-#ifndef INET_H 
+-#define INET_H 
++#ifndef INET_H
++#define INET_H
+ /*=========================================================================*\
+ * Internet domain functions
+ * LuaSocket toolkit
+ *
+ * This module implements the creation and connection of internet domain
+ * sockets, on top of the socket.h interface, and the interface of with the
+-* resolver. 
++* resolver.
+ *
+ * The function inet_aton is provided for the platforms where it is not
+ * available. The module also implements the interface of the internet
+@@ -24,11 +24,11 @@
+ 
+ int inet_open(lua_State *L);
+ 
+-const char *inet_trycreate(p_socket ps, int family, int type);
++const char *inet_trycreate(p_socket ps, int family, int type, int protocol);
+ const char *inet_tryconnect(p_socket ps, int *family, const char *address,
+         const char *serv, p_timeout tm, struct addrinfo *connecthints);
+-const char *inet_trybind(p_socket ps, const char *address, const char *serv,
+-        struct addrinfo *bindhints);
++const char *inet_trybind(p_socket ps, int *family, const char *address,
++        const char *serv, struct addrinfo *bindhints);
+ const char *inet_trydisconnect(p_socket ps, int family, p_timeout tm);
+ const char *inet_tryaccept(p_socket server, int family, p_socket client, p_timeout tm);
+ 
+diff --git a/src/io.c b/src/io.c
+index 35f46f7..a4230ce 100644
+--- a/src/io.c
++++ b/src/io.c
+@@ -25,6 +25,6 @@ const char *io_strerror(int err) {
+         case IO_DONE: return NULL;
+         case IO_CLOSED: return "closed";
+         case IO_TIMEOUT: return "timeout";
+-        default: return "unknown error"; 
++        default: return "unknown error";
+     }
+ }
+diff --git a/src/io.h b/src/io.h
+index 76a3e58..8cca08a 100644
+--- a/src/io.h
++++ b/src/io.h
+@@ -22,7 +22,7 @@ enum {
+     IO_DONE = 0,        /* operation completed successfully */
+     IO_TIMEOUT = -1,    /* operation timed out */
+     IO_CLOSED = -2,     /* the connection has been closed */
+-	IO_UNKNOWN = -3     
++	IO_UNKNOWN = -3
+ };
+ 
+ /* interface to error message function */
+diff --git a/src/ltn12.lua b/src/ltn12.lua
+index 5b10f56..575c5a7 100644
+--- a/src/ltn12.lua
++++ b/src/ltn12.lua
+@@ -9,6 +9,7 @@
+ -----------------------------------------------------------------------------
+ local string = require("string")
+ local table = require("table")
++local unpack = unpack or table.unpack
+ local base = _G
+ local _M = {}
+ if module then -- heuristic for exporting a global package table
+@@ -21,6 +22,9 @@ _M.source = source
+ _M.sink = sink
+ _M.pump = pump
+ 
++local unpack = unpack or table.unpack
++local select = base.select
++
+ -- 2048 seems to be better in windows...
+ _M.BLOCKSIZE = 2048
+ _M._VERSION = "LTN12 1.0.3"
+@@ -42,7 +46,7 @@ end
+ -- (thanks to Wim Couwenberg)
+ function filter.chain(...)
+     local arg = {...}
+-    local n = select('#',...)
++    local n = base.select('#',...)
+     local top, index = 1, 1
+     local retry = ""
+     return function(chunk)
+@@ -139,7 +143,9 @@ function source.rewind(src)
+     end
+ end
+ 
+-function source.chain(src, f)
++-- chains a source with one or several filter(s)
++function source.chain(src, f, ...)
++    if ... then f=filter.chain(f, ...) end
+     base.assert(src and f)
+     local last_in, last_out = "", ""
+     local state = "feeding"
+@@ -254,8 +260,13 @@ function sink.error(err)
+     end
+ end
+ 
+--- chains a sink with a filter
+-function sink.chain(f, snk)
++-- chains a sink with one or several filter(s)
++function sink.chain(f, snk, ...)
++    if ... then
++        local args = { f, snk, ... }
++        snk = table.remove(args, #args)
++        f = filter.chain(unpack(args))
++    end
+     base.assert(f and snk)
+     return function(chunk, err)
+         if chunk ~= "" then
+diff --git a/src/luasocket.c b/src/luasocket.c
+index e6ee747..7d9c802 100644
+--- a/src/luasocket.c
++++ b/src/luasocket.c
+@@ -17,7 +17,7 @@
+ \*=========================================================================*/
+ #include "lua.h"
+ #include "lauxlib.h"
+-
++#include "compat.h"
+ 
+ /*=========================================================================*\
+ * LuaSocket includes
+@@ -64,7 +64,7 @@ static luaL_Reg func[] = {
+ * Skip a few arguments
+ \*-------------------------------------------------------------------------*/
+ static int global_skip(lua_State *L) {
+-    int amount = luaL_checkint(L, 1);
++    int amount = luaL_checkinteger(L, 1);
+     int ret = lua_gettop(L) - amount - 1;
+     return ret >= 0 ? ret : 0;
+ }
+@@ -78,26 +78,14 @@ static int global_unload(lua_State *L) {
+     return 0;
+ }
+ 
+-#if LUA_VERSION_NUM > 501
+-int luaL_typerror (lua_State *L, int narg, const char *tname) {
+-  const char *msg = lua_pushfstring(L, "%s expected, got %s",
+-                                    tname, luaL_typename(L, narg));
+-  return luaL_argerror(L, narg, msg);
+-}
+-#endif
+-
+ /*-------------------------------------------------------------------------*\
+ * Setup basic stuff.
+ \*-------------------------------------------------------------------------*/
+ static int base_open(lua_State *L) {
+     if (socket_open()) {
+         /* export functions (and leave namespace table on top of stack) */
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+         lua_newtable(L);
+         luaL_setfuncs(L, func, 0);
+-#else
+-        luaL_openlib(L, "socket", func, 0);
+-#endif
+ #ifdef LUASOCKET_DEBUG
+         lua_pushstring(L, "_DEBUG");
+         lua_pushboolean(L, 1);
+diff --git a/src/makefile b/src/makefile
+index c24e61b..adf687f 100644
+--- a/src/makefile
++++ b/src/makefile
+@@ -20,15 +20,17 @@ PLAT?=linux
+ # lua version to build against
+ LUAV?=5.1
+ 
++# MYCFLAGS: to be set by user if needed
++MYCFLAGS=
++
++# MYLDFLAGS: to be set by user if needed
++MYLDFLAGS=
++
+ # DEBUG: NODEBUG DEBUG
+ # debug mode causes luasocket to collect and returns timing information useful
+ # for testing and debugging luasocket itself
+ DEBUG?=NODEBUG
+ 
+-# COMPAT: COMPAT NOCOMPAT
+-# when compiling for 5.2, use LUA_COMPAT_MODULE
+-COMPAT?=NOCOMPAT
+-
+ # where lua headers are found for macosx builds
+ # LUAINC_macosx:
+ # /opt/local/include
+@@ -40,7 +42,6 @@ LUAPREFIX_macosx?=/opt/local
+ CDIR_macosx?=lib/lua/$(LUAV)
+ LDIR_macosx?=share/lua/$(LUAV)
+ 
+-
+ # LUAINC_linux:
+ # /usr/include/lua$(LUAV)
+ # /usr/local/include
+@@ -52,8 +53,17 @@ LUAPREFIX_linux?=/usr/local
+ CDIR_linux?=lib/lua/$(LUAV)
+ LDIR_linux?=share/lua/$(LUAV)
+ 
++# LUAINC_freebsd:
++# /usr/local/include/lua$(LUAV)
++# where lua headers are found for freebsd builds
++LUAINC_freebsd_base?=/usr/local/include/
++LUAINC_freebsd?=$(LUAINC_freebsd_base)/lua$(LUAV)
++LUAPREFIX_freebsd?=/usr/local/
++CDIR_freebsd?=lib/lua/$(LUAV)
++LDIR_freebsd?=share/lua/$(LUAV)
++
+ # where lua headers are found for mingw builds
+-# LUAINC_mingw: 
++# LUAINC_mingw:
+ # /opt/local/include
+ LUAINC_mingw_base?=/usr/include
+ LUAINC_mingw?=$(LUAINC_mingw_base)/lua/$(LUAV)
+@@ -67,13 +77,21 @@ LDIR_mingw?=lua/$(LUAV)/lua
+ # LUAINC_win32:
+ # LUALIB_win32:
+ # where lua headers and libraries are found for win32 builds
+-LUAINC_win32_base?=
+-LUAINC_win32?=$(LUAINC_win32_base)/lua/$(LUAV)
+-PLATFORM_win32?=Release
+ LUAPREFIX_win32?=
+-CDIR_win32?=lua/$(LUAV)/$(PLATFORM_win32)
+-LDIR_win32?=lua/$(LUAV)/$(PLATFORM_win32)/lua
+-LUALIB_win32?=$(LUAPREFIX_win32)/lua/$(LUAV)/$(PLATFORM_win32)
++LUAINC_win32?=$(LUAPREFIX_win32)/include/lua/$(LUAV)
++PLATFORM_win32?=Release
++CDIR_win32?=bin/lua/$(LUAV)/$(PLATFORM_win32)
++LDIR_win32?=bin/lua/$(LUAV)/$(PLATFORM_win32)/lua
++LUALIB_win32?=$(LUAPREFIX_win32)/lib/lua/$(LUAV)/$(PLATFORM_win32)
++LUALIBNAME_win32?=lua$(subst .,,$(LUAV)).lib 
++
++
++# LUAINC_solaris:
++LUAINC_solaris_base?=/usr/include
++LUAINC_solaris?=$(LUAINC_solaris_base)/lua/$(LUAV)
++LUAPREFIX_solaris?=/usr/local
++CDIR_solaris?=lib/lua/$(LUAV)
++LDIR_solaris?=share/lua/$(LUAV)
+ 
+ # prefix: /usr/local /usr /opt/local /sw
+ # the top of the default install tree
+@@ -121,7 +139,7 @@ print:
+ #------
+ # Supported platforms
+ #
+-PLATS= macosx linux win32 mingw
++PLATS= macosx linux win32 mingw solaris
+ 
+ #------
+ # Compiler and linker settings
+@@ -129,11 +147,11 @@ PLATS= macosx linux win32 mingw
+ SO_macosx=so
+ O_macosx=o
+ CC_macosx=gcc
+-DEF_macosx= -DLUASOCKET_$(DEBUG) -DUNIX_HAS_SUN_LEN -DLUA_$(COMPAT)_MODULE \
++DEF_macosx= -DLUASOCKET_$(DEBUG) -DUNIX_HAS_SUN_LEN \
+ 	-DLUASOCKET_API='__attribute__((visibility("default")))' \
+ 	-DUNIX_API='__attribute__((visibility("default")))' \
+ 	-DMIME_API='__attribute__((visibility("default")))'
+-CFLAGS_macosx= -I$(LUAINC) $(DEF) -pedantic -Wall -O2 -fno-common \
++CFLAGS_macosx= -I$(LUAINC) $(DEF) -Wall -O2 -fno-common \
+ 	-fvisibility=hidden
+ LDFLAGS_macosx= -bundle -undefined dynamic_lookup -o 
+ LD_macosx= export MACOSX_DEPLOYMENT_TARGET="10.3"; gcc
+@@ -145,11 +163,11 @@ SOCKET_macosx=usocket.o
+ SO_linux=so
+ O_linux=o
+ CC_linux=gcc
+-DEF_linux=-DLUASOCKET_$(DEBUG) -DLUA_$(COMPAT)_MODULE \
++DEF_linux=-DLUASOCKET_$(DEBUG) \
+ 	-DLUASOCKET_API='__attribute__((visibility("default")))' \
+ 	-DUNIX_API='__attribute__((visibility("default")))' \
+ 	-DMIME_API='__attribute__((visibility("default")))'
+-CFLAGS_linux= -I$(LUAINC) $(DEF) -pedantic -Wall -Wshadow -Wextra \
++CFLAGS_linux= -I$(LUAINC) $(DEF) -Wall -Wshadow -Wextra \
+ 	-Wimplicit -O2 -ggdb3 -fpic -fvisibility=hidden
+ LDFLAGS_linux=-O -shared -fpic -o 
+ LD_linux=gcc
+@@ -157,14 +175,46 @@ SOCKET_linux=usocket.o
+ 
+ #------
+ # Compiler and linker settings
++# for FreeBSD
++SO_freebsd=so
++O_freebsd=o
++CC_freebsd=gcc
++DEF_freebsd=-DLUASOCKET_$(DEBUG) \
++	-DLUASOCKET_API='__attribute__((visibility("default")))' \
++	-DUNIX_API='__attribute__((visibility("default")))' \
++	-DMIME_API='__attribute__((visibility("default")))'
++CFLAGS_freebsd= -I$(LUAINC) $(DEF) -Wall -Wshadow -Wextra \
++	-Wimplicit -O2 -ggdb3 -fpic -fvisibility=hidden
++LDFLAGS_freebsd=-O -shared -fpic -o 
++LD_freebsd=gcc
++SOCKET_freebsd=usocket.o
++
++#------
++# Compiler and linker settings
++# for Solaris
++SO_solaris=so
++O_solaris=o
++CC_solaris=gcc
++DEF_solaris=-DLUASOCKET_$(DEBUG) \
++	-DLUASOCKET_API='__attribute__((visibility("default")))' \
++	-DUNIX_API='__attribute__((visibility("default")))' \
++	-DMIME_API='__attribute__((visibility("default")))'
++CFLAGS_solaris=-I$(LUAINC) $(DEF) -Wall -Wshadow -Wextra \
++	-Wimplicit -O2 -ggdb3 -fpic -fvisibility=hidden   
++LDFLAGS_solaris=-lnsl -lsocket -lresolv -O -shared -fpic -o 
++LD_solaris=gcc
++SOCKET_solaris=usocket.o
++
++#------
++# Compiler and linker settings
+ # for MingW
+ SO_mingw=dll
+ O_mingw=o
+ CC_mingw=gcc
+-DEF_mingw= -DLUASOCKET_INET_PTON -DLUASOCKET_$(DEBUG) -DLUA_$(COMPAT)_MODULE \
++DEF_mingw= -DLUASOCKET_INET_PTON -DLUASOCKET_$(DEBUG) \
+ 	-DWINVER=0x0501 -DLUASOCKET_API='__declspec(dllexport)' \
+ 	-DMIME_API='__declspec(dllexport)'
+-CFLAGS_mingw= -I$(LUAINC) $(DEF) -pedantic -Wall -O2 -fno-common \
++CFLAGS_mingw= -I$(LUAINC) $(DEF) -Wall -O2 -fno-common \
+ 	-fvisibility=hidden
+ LDFLAGS_mingw= $(LUALIB) -shared -Wl,-s -lws2_32 -o 
+ LD_mingw=gcc
+@@ -179,8 +229,7 @@ O_win32=obj
+ CC_win32=cl
+ DEF_win32= //D "WIN32" //D "NDEBUG" //D "_WINDOWS" //D "_USRDLL" \
+      //D "LUASOCKET_API=__declspec(dllexport)" //D "_CRT_SECURE_NO_WARNINGS" \
+-     //D "_WINDLL" //D "LUA_$(COMPAT)_MODULE" \
+-	 //D "MIME_API=__declspec(dllexport)" \
++     //D "_WINDLL" //D "MIME_API=__declspec(dllexport)" \
+      //D "LUASOCKET_$(DEBUG)" 
+ CFLAGS_win32=//I "$(LUAINC)" $(DEF) //O2 //Ot //MD //W3 //nologo
+ LDFLAGS_win32= //nologo //link //NOLOGO //DLL //INCREMENTAL:NO \
+@@ -188,7 +237,7 @@ LDFLAGS_win32= //nologo //link //NOLOGO //DLL //INCREMENTAL:NO \
+     //MANIFESTUAC:"level='asInvoker' uiAccess='false'" \
+ 	//SUBSYSTEM:WINDOWS //OPT:REF //OPT:ICF //DYNAMICBASE:NO \
+     //MACHINE:X86 /LIBPATH:"$(shell cmd //c echo $(LUALIB))" \
+-	lua$(subst .,,$(LUAV)).lib ws2_32.lib //OUT:
++	$(LUALIBNAME_win32) ws2_32.lib //OUT:
+ LD_win32=cl
+ SOCKET_win32=wsocket.obj
+ 
+@@ -204,8 +253,8 @@ SO=$(SO_$(PLAT))
+ O=$(O_$(PLAT))
+ SOCKET_V=3.0-rc1
+ MIME_V=1.0.3
+-SOCKET_SO=socket.$(SO).$(SOCKET_V)
+-MIME_SO=mime.$(SO).$(MIME_V)
++SOCKET_SO=socket-$(SOCKET_V).$(SO)
++MIME_SO=mime-$(MIME_V).$(SO)
+ UNIX_SO=unix.$(SO)
+ SERIAL_SO=serial.$(SO)
+ SOCKET=$(SOCKET_$(PLAT))
+@@ -215,8 +264,8 @@ SOCKET=$(SOCKET_$(PLAT))
+ #
+ CC=$(CC_$(PLAT))
+ DEF=$(DEF_$(PLAT))
+-CFLAGS=$(CFLAGS_$(PLAT))
+-LDFLAGS=$(LDFLAGS_$(PLAT))
++CFLAGS=$(MYCFLAGS) $(CFLAGS_$(PLAT))
++LDFLAGS=$(MYLDFLAGS) $(LDFLAGS_$(PLAT))
+ LD=$(LD_$(PLAT))
+ LUAINC= $(LUAINC_$(PLAT))
+ LUALIB= $(LUALIB_$(PLAT))
+@@ -230,6 +279,7 @@ SOCKET_OBJS= \
+ 	buffer.$(O) \
+ 	io.$(O) \
+ 	auxiliar.$(O) \
++	compat.$(O) \
+ 	options.$(O) \
+ 	inet.$(O) \
+ 	$(SOCKET) \
+@@ -242,7 +292,8 @@ SOCKET_OBJS= \
+ # Modules belonging mime-core
+ #
+ MIME_OBJS= \
+-	mime.$(O)
++	mime.$(O) \
++	compat.$(O)
+ 
+ #------
+ # Modules belonging unix (local domain sockets)
+@@ -259,7 +310,7 @@ UNIX_OBJS=\
+ #------
+ # Modules belonging to serial (device streams)
+ #
+-SERIAL_OBJS:=\
++SERIAL_OBJS=\
+ 	buffer.$(O) \
+ 	auxiliar.$(O) \
+ 	options.$(O) \
+@@ -289,6 +340,10 @@ TO_TOP_LDIR= \
+ #
+ default: $(PLAT)
+ 
++
++freebsd:
++	$(MAKE) all-unix PLAT=freebsd
++
+ macosx:
+ 	$(MAKE) all-unix PLAT=macosx
+ 
+@@ -300,6 +355,9 @@ linux:
+ 
+ mingw:
+ 	$(MAKE) all PLAT=mingw
++	
++solaris:
++	$(MAKE) all-unix PLAT=solaris
+ 
+ none:
+ 	@echo "Please run"
+@@ -349,6 +407,7 @@ clean:
+ #------
+ # List of dependencies
+ #
++compat.$(O): compat.c compat.h
+ auxiliar.$(O): auxiliar.c auxiliar.h
+ buffer.$(O): buffer.c buffer.h io.h timeout.h
+ except.$(O): except.c except.h
+diff --git a/src/mbox.lua b/src/mbox.lua
+index 7724ae2..ed9e781 100644
+--- a/src/mbox.lua
++++ b/src/mbox.lua
+@@ -61,7 +61,7 @@ function _M.parse_from(from)
+ end
+ 
+ function _M.split_mbox(mbox_s)
+-    mbox = {}
++    local mbox = {}
+     mbox_s = string.gsub(mbox_s, "\r\n", "\n") .."\n\nFrom \n"
+     local nj, i, j = 1, 1, 1
+     while 1 do
+diff --git a/src/mime.c b/src/mime.c
+index dd37dcf..ed44104 100644
+--- a/src/mime.c
++++ b/src/mime.c
+@@ -6,10 +6,7 @@
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
+-
+-#if !defined(LUA_VERSION_NUM) || (LUA_VERSION_NUM < 501)
+-#include "compat-5.1.h"
+-#endif
++#include "compat.h"
+ 
+ #include "mime.h"
+ 
+@@ -41,7 +38,7 @@ static size_t b64decode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
+ static void qpsetup(UC *class, UC *unbase);
+ static void qpquote(UC c, luaL_Buffer *buffer);
+ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
+-static size_t qpencode(UC c, UC *input, size_t size, 
++static size_t qpencode(UC c, UC *input, size_t size,
+         const char *marker, luaL_Buffer *buffer);
+ static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer);
+ 
+@@ -81,12 +78,8 @@ static UC b64unbase[256];
+ \*-------------------------------------------------------------------------*/
+ MIME_API int luaopen_mime_core(lua_State *L)
+ {
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+     lua_newtable(L);
+     luaL_setfuncs(L, func, 0);
+-#else
+-    luaL_openlib(L, "mime", func, 0);
+-#endif
+     /* make version string available to scripts */
+     lua_pushstring(L, "_VERSION");
+     lua_pushstring(L, MIME_VERSION);
+@@ -103,15 +96,15 @@ MIME_API int luaopen_mime_core(lua_State *L)
+ /*-------------------------------------------------------------------------*\
+ * Incrementaly breaks a string into lines. The string can have CRLF breaks.
+ * A, n = wrp(l, B, length)
+-* A is a copy of B, broken into lines of at most 'length' bytes. 
+-* 'l' is how many bytes are left for the first line of B. 
+-* 'n' is the number of bytes left in the last line of A. 
++* A is a copy of B, broken into lines of at most 'length' bytes.
++* 'l' is how many bytes are left for the first line of B.
++* 'n' is the number of bytes left in the last line of A.
+ \*-------------------------------------------------------------------------*/
+ static int mime_global_wrp(lua_State *L)
+ {
+     size_t size = 0;
+     int left = (int) luaL_checknumber(L, 1);
+-    const UC *input = (UC *) luaL_optlstring(L, 2, NULL, &size);
++    const UC *input = (const UC *) luaL_optlstring(L, 2, NULL, &size);
+     const UC *last = input + size;
+     int length = (int) luaL_optnumber(L, 3, 76);
+     luaL_Buffer buffer;
+@@ -123,7 +116,7 @@ static int mime_global_wrp(lua_State *L)
+         else lua_pushnil(L);
+         lua_pushnumber(L, length);
+         return 2;
+-    } 
++    }
+     luaL_buffinit(L, &buffer);
+     while (input < last) {
+         switch (*input) {
+@@ -150,9 +143,9 @@ static int mime_global_wrp(lua_State *L)
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Fill base64 decode map. 
++* Fill base64 decode map.
+ \*-------------------------------------------------------------------------*/
+-static void b64setup(UC *unbase) 
++static void b64setup(UC *unbase)
+ {
+     int i;
+     for (i = 0; i <= 255; i++) unbase[i] = (UC) 255;
+@@ -161,11 +154,11 @@ static void b64setup(UC *unbase)
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Acumulates bytes in input buffer until 3 bytes are available. 
++* Acumulates bytes in input buffer until 3 bytes are available.
+ * Translate the 3 bytes into Base64 form and append to buffer.
+ * Returns new number of bytes in buffer.
+ \*-------------------------------------------------------------------------*/
+-static size_t b64encode(UC c, UC *input, size_t size, 
++static size_t b64encode(UC c, UC *input, size_t size,
+         luaL_Buffer *buffer)
+ {
+     input[size++] = c;
+@@ -174,7 +167,7 @@ static size_t b64encode(UC c, UC *input, size_t size,
+         unsigned long value = 0;
+         value += input[0]; value <<= 8;
+         value += input[1]; value <<= 8;
+-        value += input[2]; 
++        value += input[2];
+         code[3] = b64base[value & 0x3f]; value >>= 6;
+         code[2] = b64base[value & 0x3f]; value >>= 6;
+         code[1] = b64base[value & 0x3f]; value >>= 6;
+@@ -186,11 +179,11 @@ static size_t b64encode(UC c, UC *input, size_t size,
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Encodes the Base64 last 1 or 2 bytes and adds padding '=' 
++* Encodes the Base64 last 1 or 2 bytes and adds padding '='
+ * Result, if any, is appended to buffer.
+ * Returns 0.
+ \*-------------------------------------------------------------------------*/
+-static size_t b64pad(const UC *input, size_t size, 
++static size_t b64pad(const UC *input, size_t size,
+         luaL_Buffer *buffer)
+ {
+     unsigned long value = 0;
+@@ -203,7 +196,7 @@ static size_t b64pad(const UC *input, size_t size,
+             luaL_addlstring(buffer, (char *) code, 4);
+             break;
+         case 2:
+-            value = input[0]; value <<= 8; 
++            value = input[0]; value <<= 8;
+             value |= input[1]; value <<= 2;
+             code[2] = b64base[value & 0x3f]; value >>= 6;
+             code[1] = b64base[value & 0x3f]; value >>= 6;
+@@ -217,11 +210,11 @@ static size_t b64pad(const UC *input, size_t size,
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Acumulates bytes in input buffer until 4 bytes are available. 
++* Acumulates bytes in input buffer until 4 bytes are available.
+ * Translate the 4 bytes from Base64 form and append to buffer.
+ * Returns new number of bytes in buffer.
+ \*-------------------------------------------------------------------------*/
+-static size_t b64decode(UC c, UC *input, size_t size, 
++static size_t b64decode(UC c, UC *input, size_t size,
+         luaL_Buffer *buffer)
+ {
+     /* ignore invalid characters */
+@@ -239,7 +232,7 @@ static size_t b64decode(UC c, UC *input, size_t size,
+         decoded[1] = (UC) (value & 0xff); value >>= 8;
+         decoded[0] = (UC) value;
+         /* take care of paddding */
+-        valid = (input[2] == '=') ? 1 : (input[3] == '=') ? 2 : 3; 
++        valid = (input[2] == '=') ? 1 : (input[3] == '=') ? 2 : 3;
+         luaL_addlstring(buffer, (char *) decoded, valid);
+         return 0;
+     /* need more data */
+@@ -251,7 +244,7 @@ static size_t b64decode(UC c, UC *input, size_t size,
+ * A, B = b64(C, D)
+ * A is the encoded version of the largest prefix of C .. D that is
+ * divisible by 3. B has the remaining bytes of C .. D, *without* encoding.
+-* The easiest thing would be to concatenate the two strings and 
++* The easiest thing would be to concatenate the two strings and
+ * encode the result, but we can't afford that or Lua would dupplicate
+ * every chunk we received.
+ \*-------------------------------------------------------------------------*/
+@@ -259,7 +252,7 @@ static int mime_global_b64(lua_State *L)
+ {
+     UC atom[3];
+     size_t isize = 0, asize = 0;
+-    const UC *input = (UC *) luaL_optlstring(L, 1, NULL, &isize);
++    const UC *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize);
+     const UC *last = input + isize;
+     luaL_Buffer buffer;
+     /* end-of-input blackhole */
+@@ -272,9 +265,9 @@ static int mime_global_b64(lua_State *L)
+     lua_settop(L, 2);
+     /* process first part of the input */
+     luaL_buffinit(L, &buffer);
+-    while (input < last) 
++    while (input < last)
+         asize = b64encode(*input++, atom, asize, &buffer);
+-    input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
++    input = (const UC *) luaL_optlstring(L, 2, NULL, &isize);
+     /* if second part is nil, we are done */
+     if (!input) {
+         size_t osize = 0;
+@@ -288,7 +281,7 @@ static int mime_global_b64(lua_State *L)
+     }
+     /* otherwise process the second part */
+     last = input + isize;
+-    while (input < last) 
++    while (input < last)
+         asize = b64encode(*input++, atom, asize, &buffer);
+     luaL_pushresult(&buffer);
+     lua_pushlstring(L, (char *) atom, asize);
+@@ -305,7 +298,7 @@ static int mime_global_unb64(lua_State *L)
+ {
+     UC atom[4];
+     size_t isize = 0, asize = 0;
+-    const UC *input = (UC *) luaL_optlstring(L, 1, NULL, &isize);
++    const UC *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize);
+     const UC *last = input + isize;
+     luaL_Buffer buffer;
+     /* end-of-input blackhole */
+@@ -318,9 +311,9 @@ static int mime_global_unb64(lua_State *L)
+     lua_settop(L, 2);
+     /* process first part of the input */
+     luaL_buffinit(L, &buffer);
+-    while (input < last) 
++    while (input < last)
+         asize = b64decode(*input++, atom, asize, &buffer);
+-    input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
++    input = (const UC *) luaL_optlstring(L, 2, NULL, &isize);
+     /* if second is nil, we are done */
+     if (!input) {
+         size_t osize = 0;
+@@ -333,7 +326,7 @@ static int mime_global_unb64(lua_State *L)
+     }
+     /* otherwise, process the rest of the input */
+     last = input + isize;
+-    while (input < last) 
++    while (input < last)
+         asize = b64decode(*input++, atom, asize, &buffer);
+     luaL_pushresult(&buffer);
+     lua_pushlstring(L, (char *) atom, asize);
+@@ -349,7 +342,7 @@ static int mime_global_unb64(lua_State *L)
+ * 9 and 32 can be plain, unless in the end of a line, where must be =XX
+ * encoded lines must be no longer than 76 not counting CRLF
+ * soft line-break are =CRLF
+-* To encode one byte, we need to see the next two. 
++* To encode one byte, we need to see the next two.
+ * Worst case is when we see a space, and wonder if a CRLF is comming
+ \*-------------------------------------------------------------------------*/
+ /*-------------------------------------------------------------------------*\
+@@ -362,7 +355,7 @@ static void qpsetup(UC *cl, UC *unbase)
+     for (i = 0; i < 256; i++) cl[i] = QP_QUOTED;
+     for (i = 33; i <= 60; i++) cl[i] = QP_PLAIN;
+     for (i = 62; i <= 126; i++) cl[i] = QP_PLAIN;
+-    cl['\t'] = QP_IF_LAST; 
++    cl['\t'] = QP_IF_LAST;
+     cl[' '] = QP_IF_LAST;
+     cl['\r'] = QP_CR;
+     for (i = 0; i < 256; i++) unbase[i] = 255;
+@@ -388,9 +381,9 @@ static void qpquote(UC c, luaL_Buffer *buffer)
+ 
+ /*-------------------------------------------------------------------------*\
+ * Accumulate characters until we are sure about how to deal with them.
+-* Once we are sure, output to the buffer, in the correct form. 
++* Once we are sure, output to the buffer, in the correct form.
+ \*-------------------------------------------------------------------------*/
+-static size_t qpencode(UC c, UC *input, size_t size, 
++static size_t qpencode(UC c, UC *input, size_t size,
+         const char *marker, luaL_Buffer *buffer)
+ {
+     input[size++] = c;
+@@ -431,7 +424,7 @@ static size_t qpencode(UC c, UC *input, size_t size,
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Deal with the final characters 
++* Deal with the final characters
+ \*-------------------------------------------------------------------------*/
+ static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer)
+ {
+@@ -448,8 +441,8 @@ static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer)
+ * Incrementally converts a string to quoted-printable
+ * A, B = qp(C, D, marker)
+ * Marker is the text to be used to replace CRLF sequences found in A.
+-* A is the encoded version of the largest prefix of C .. D that 
+-* can be encoded without doubts. 
++* A is the encoded version of the largest prefix of C .. D that
++* can be encoded without doubts.
+ * B has the remaining bytes of C .. D, *without* encoding.
+ \*-------------------------------------------------------------------------*/
+ static int mime_global_qp(lua_State *L)
+@@ -457,7 +450,7 @@ static int mime_global_qp(lua_State *L)
+ 
+     size_t asize = 0, isize = 0;
+     UC atom[3];
+-    const UC *input = (UC *) luaL_optlstring(L, 1, NULL, &isize);
++    const UC *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize);
+     const UC *last = input + isize;
+     const char *marker = luaL_optstring(L, 3, CRLF);
+     luaL_Buffer buffer;
+@@ -473,7 +466,7 @@ static int mime_global_qp(lua_State *L)
+     luaL_buffinit(L, &buffer);
+     while (input < last)
+         asize = qpencode(*input++, atom, asize, marker, &buffer);
+-    input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
++    input = (const UC *) luaL_optlstring(L, 2, NULL, &isize);
+     /* if second part is nil, we are done */
+     if (!input) {
+         asize = qppad(atom, asize, &buffer);
+@@ -493,7 +486,7 @@ static int mime_global_qp(lua_State *L)
+ 
+ /*-------------------------------------------------------------------------*\
+ * Accumulate characters until we are sure about how to deal with them.
+-* Once we are sure, output the to the buffer, in the correct form. 
++* Once we are sure, output the to the buffer, in the correct form.
+ \*-------------------------------------------------------------------------*/
+ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
+     int d;
+@@ -501,8 +494,8 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
+     /* deal with all characters we can deal */
+     switch (input[0]) {
+         /* if we have an escape character */
+-        case '=': 
+-            if (size < 3) return size; 
++        case '=':
++            if (size < 3) return size;
+             /* eliminate soft line break */
+             if (input[1] == '\r' && input[2] == '\n') return 0;
+             /* decode quoted representation */
+@@ -512,7 +505,7 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
+             else luaL_addchar(buffer, (char) ((c << 4) + d));
+             return 0;
+         case '\r':
+-            if (size < 2) return size; 
++            if (size < 2) return size;
+             if (input[1] == '\n') luaL_addlstring(buffer, (char *)input, 2);
+             return 0;
+         default:
+@@ -525,15 +518,15 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
+ /*-------------------------------------------------------------------------*\
+ * Incrementally decodes a string in quoted-printable
+ * A, B = qp(C, D)
+-* A is the decoded version of the largest prefix of C .. D that 
+-* can be decoded without doubts. 
++* A is the decoded version of the largest prefix of C .. D that
++* can be decoded without doubts.
+ * B has the remaining bytes of C .. D, *without* decoding.
+ \*-------------------------------------------------------------------------*/
+ static int mime_global_unqp(lua_State *L)
+ {
+     size_t asize = 0, isize = 0;
+     UC atom[3];
+-    const UC *input = (UC *) luaL_optlstring(L, 1, NULL, &isize);
++    const UC *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize);
+     const UC *last = input + isize;
+     luaL_Buffer buffer;
+     /* end-of-input blackhole */
+@@ -548,14 +541,14 @@ static int mime_global_unqp(lua_State *L)
+     luaL_buffinit(L, &buffer);
+     while (input < last)
+         asize = qpdecode(*input++, atom, asize, &buffer);
+-    input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
++    input = (const UC *) luaL_optlstring(L, 2, NULL, &isize);
+     /* if second part is nil, we are done */
+     if (!input) {
+         luaL_pushresult(&buffer);
+         if (!(*lua_tostring(L, -1))) lua_pushnil(L);
+         lua_pushnil(L);
+         return 2;
+-    } 
++    }
+     /* otherwise process rest of input */
+     last = input + isize;
+     while (input < last)
+@@ -568,9 +561,9 @@ static int mime_global_unqp(lua_State *L)
+ /*-------------------------------------------------------------------------*\
+ * Incrementally breaks a quoted-printed string into lines
+ * A, n = qpwrp(l, B, length)
+-* A is a copy of B, broken into lines of at most 'length' bytes. 
+-* 'l' is how many bytes are left for the first line of B. 
+-* 'n' is the number of bytes left in the last line of A. 
++* A is a copy of B, broken into lines of at most 'length' bytes.
++* 'l' is how many bytes are left for the first line of B.
++* 'n' is the number of bytes left in the last line of A.
+ * There are two complications: lines can't be broken in the middle
+ * of an encoded =XX, and there might be line breaks already
+ \*-------------------------------------------------------------------------*/
+@@ -578,7 +571,7 @@ static int mime_global_qpwrp(lua_State *L)
+ {
+     size_t size = 0;
+     int left = (int) luaL_checknumber(L, 1);
+-    const UC *input = (UC *) luaL_optlstring(L, 2, NULL, &size);
++    const UC *input = (const UC *) luaL_optlstring(L, 2, NULL, &size);
+     const UC *last = input + size;
+     int length = (int) luaL_optnumber(L, 3, 76);
+     luaL_Buffer buffer;
+@@ -603,11 +596,11 @@ static int mime_global_qpwrp(lua_State *L)
+                 if (left <= 3) {
+                     left = length;
+                     luaL_addstring(&buffer, EQCRLF);
+-                } 
++                }
+                 luaL_addchar(&buffer, *input);
+                 left--;
+                 break;
+-            default: 
++            default:
+                 if (left <= 1) {
+                     left = length;
+                     luaL_addstring(&buffer, EQCRLF);
+@@ -635,7 +628,7 @@ static int mime_global_qpwrp(lua_State *L)
+ * last is the previous character
+ \*-------------------------------------------------------------------------*/
+ #define eolcandidate(c) (c == '\r' || c == '\n')
+-static int eolprocess(int c, int last, const char *marker, 
++static int eolprocess(int c, int last, const char *marker,
+         luaL_Buffer *buffer)
+ {
+     if (eolcandidate(c)) {
+@@ -653,15 +646,15 @@ static int eolprocess(int c, int last, const char *marker,
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Converts a string to uniform EOL convention. 
++* Converts a string to uniform EOL convention.
+ * A, n = eol(o, B, marker)
+ * A is the converted version of the largest prefix of B that can be
+-* converted unambiguously. 'o' is the context returned by the previous 
++* converted unambiguously. 'o' is the context returned by the previous
+ * call. 'n' is the new context.
+ \*-------------------------------------------------------------------------*/
+ static int mime_global_eol(lua_State *L)
+ {
+-    int ctx = luaL_checkint(L, 1);
++    int ctx = luaL_checkinteger(L, 1);
+     size_t isize = 0;
+     const char *input = luaL_optlstring(L, 2, NULL, &isize);
+     const char *last = input + isize;
+@@ -683,18 +676,18 @@ static int mime_global_eol(lua_State *L)
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Takes one byte and stuff it if needed. 
++* Takes one byte and stuff it if needed.
+ \*-------------------------------------------------------------------------*/
+ static size_t dot(int c, size_t state, luaL_Buffer *buffer)
+ {
+     luaL_addchar(buffer, (char) c);
+     switch (c) {
+-        case '\r': 
++        case '\r':
+             return 1;
+-        case '\n': 
+-            return (state == 1)? 2: 0; 
+-        case '.':  
+-            if (state == 2) 
++        case '\n':
++            return (state == 1)? 2: 0;
++        case '.':
++            if (state == 2)
+                 luaL_addchar(buffer, '.');
+         default:
+             return 0;
+@@ -719,7 +712,7 @@ static int mime_global_dot(lua_State *L)
+     }
+     /* process all input */
+     luaL_buffinit(L, &buffer);
+-    while (input < last) 
++    while (input < last)
+         state = dot(*input++, state, &buffer);
+     luaL_pushresult(&buffer);
+     lua_pushnumber(L, (lua_Number) state);
+diff --git a/src/options.c b/src/options.c
+index 8ac2a14..20f4c28 100644
+--- a/src/options.c
++++ b/src/options.c
+@@ -1,8 +1,8 @@
+ /*=========================================================================*\
+-* Common option interface 
++* Common option interface
+ * LuaSocket toolkit
+ \*=========================================================================*/
+-#include  
++#include 
+ 
+ #include "lauxlib.h"
+ 
+@@ -20,9 +20,9 @@ static int opt_setboolean(lua_State *L, p_socket ps, int level, int name);
+ static int opt_getboolean(lua_State *L, p_socket ps, int level, int name);
+ static int opt_setint(lua_State *L, p_socket ps, int level, int name);
+ static int opt_getint(lua_State *L, p_socket ps, int level, int name);
+-static int opt_set(lua_State *L, p_socket ps, int level, int name, 
++static int opt_set(lua_State *L, p_socket ps, int level, int name,
+         void *val, int len);
+-static int opt_get(lua_State *L, p_socket ps, int level, int name, 
++static int opt_get(lua_State *L, p_socket ps, int level, int name,
+         void *val, int* len);
+ 
+ /*=========================================================================*\
+@@ -60,29 +60,29 @@ int opt_meth_getoption(lua_State *L, p_opt opt, p_socket ps)
+ /* enables reuse of local address */
+ int opt_set_reuseaddr(lua_State *L, p_socket ps)
+ {
+-    return opt_setboolean(L, ps, SOL_SOCKET, SO_REUSEADDR); 
++    return opt_setboolean(L, ps, SOL_SOCKET, SO_REUSEADDR);
+ }
+ 
+ int opt_get_reuseaddr(lua_State *L, p_socket ps)
+ {
+-    return opt_getboolean(L, ps, SOL_SOCKET, SO_REUSEADDR); 
++    return opt_getboolean(L, ps, SOL_SOCKET, SO_REUSEADDR);
+ }
+ 
+ /* enables reuse of local port */
+ int opt_set_reuseport(lua_State *L, p_socket ps)
+ {
+-    return opt_setboolean(L, ps, SOL_SOCKET, SO_REUSEPORT); 
++    return opt_setboolean(L, ps, SOL_SOCKET, SO_REUSEPORT);
+ }
+ 
+ int opt_get_reuseport(lua_State *L, p_socket ps)
+ {
+-    return opt_getboolean(L, ps, SOL_SOCKET, SO_REUSEPORT); 
++    return opt_getboolean(L, ps, SOL_SOCKET, SO_REUSEPORT);
+ }
+ 
+ /* disables the Naggle algorithm */
+ int opt_set_tcp_nodelay(lua_State *L, p_socket ps)
+ {
+-    return opt_setboolean(L, ps, IPPROTO_TCP, TCP_NODELAY); 
++    return opt_setboolean(L, ps, IPPROTO_TCP, TCP_NODELAY);
+ }
+ 
+ int opt_get_tcp_nodelay(lua_State *L, p_socket ps)
+@@ -92,12 +92,12 @@ int opt_get_tcp_nodelay(lua_State *L, p_socket ps)
+ 
+ int opt_set_keepalive(lua_State *L, p_socket ps)
+ {
+-    return opt_setboolean(L, ps, SOL_SOCKET, SO_KEEPALIVE); 
++    return opt_setboolean(L, ps, SOL_SOCKET, SO_KEEPALIVE);
+ }
+ 
+ int opt_get_keepalive(lua_State *L, p_socket ps)
+ {
+-    return opt_getboolean(L, ps, SOL_SOCKET, SO_KEEPALIVE); 
++    return opt_getboolean(L, ps, SOL_SOCKET, SO_KEEPALIVE);
+ }
+ 
+ int opt_set_dontroute(lua_State *L, p_socket ps)
+@@ -105,11 +105,21 @@ int opt_set_dontroute(lua_State *L, p_socket ps)
+     return opt_setboolean(L, ps, SOL_SOCKET, SO_DONTROUTE);
+ }
+ 
++int opt_get_dontroute(lua_State *L, p_socket ps)
++{
++    return opt_getboolean(L, ps, SOL_SOCKET, SO_DONTROUTE);
++}
++
+ int opt_set_broadcast(lua_State *L, p_socket ps)
+ {
+     return opt_setboolean(L, ps, SOL_SOCKET, SO_BROADCAST);
+ }
+ 
++int opt_get_broadcast(lua_State *L, p_socket ps)
++{
++    return opt_getboolean(L, ps, SOL_SOCKET, SO_BROADCAST);
++}
++
+ int opt_set_ip6_unicast_hops(lua_State *L, p_socket ps)
+ {
+   return opt_setint(L, ps, IPPROTO_IPV6, IPV6_UNICAST_HOPS);
+@@ -156,12 +166,12 @@ int opt_set_linger(lua_State *L, p_socket ps)
+     if (!lua_istable(L, 3)) auxiliar_typeerror(L,3,lua_typename(L, LUA_TTABLE));
+     lua_pushstring(L, "on");
+     lua_gettable(L, 3);
+-    if (!lua_isboolean(L, -1)) 
++    if (!lua_isboolean(L, -1))
+         luaL_argerror(L, 3, "boolean 'on' field expected");
+     li.l_onoff = (u_short) lua_toboolean(L, -1);
+     lua_pushstring(L, "timeout");
+     lua_gettable(L, 3);
+-    if (!lua_isnumber(L, -1)) 
++    if (!lua_isnumber(L, -1))
+         luaL_argerror(L, 3, "number 'timeout' field expected");
+     li.l_linger = (u_short) lua_tonumber(L, -1);
+     return opt_set(L, ps, SOL_SOCKET, SO_LINGER, (char *) &li, sizeof(li));
+@@ -194,7 +204,7 @@ int opt_set_ip_multicast_if(lua_State *L, p_socket ps)
+     val.s_addr = htonl(INADDR_ANY);
+     if (strcmp(address, "*") && !inet_aton(address, &val))
+         luaL_argerror(L, 3, "ip expected");
+-    return opt_set(L, ps, IPPROTO_IP, IP_MULTICAST_IF, 
++    return opt_set(L, ps, IPPROTO_IP, IP_MULTICAST_IF,
+         (char *) &val, sizeof(val));
+ }
+ 
+@@ -250,17 +260,17 @@ static int opt_setmembership(lua_State *L, p_socket ps, int level, int name)
+     if (!lua_istable(L, 3)) auxiliar_typeerror(L,3,lua_typename(L, LUA_TTABLE));
+     lua_pushstring(L, "multiaddr");
+     lua_gettable(L, 3);
+-    if (!lua_isstring(L, -1)) 
++    if (!lua_isstring(L, -1))
+         luaL_argerror(L, 3, "string 'multiaddr' field expected");
+-    if (!inet_aton(lua_tostring(L, -1), &val.imr_multiaddr)) 
++    if (!inet_aton(lua_tostring(L, -1), &val.imr_multiaddr))
+         luaL_argerror(L, 3, "invalid 'multiaddr' ip address");
+     lua_pushstring(L, "interface");
+     lua_gettable(L, 3);
+-    if (!lua_isstring(L, -1)) 
++    if (!lua_isstring(L, -1))
+         luaL_argerror(L, 3, "string 'interface' field expected");
+     val.imr_interface.s_addr = htonl(INADDR_ANY);
+     if (strcmp(lua_tostring(L, -1), "*") &&
+-            !inet_aton(lua_tostring(L, -1), &val.imr_interface)) 
++            !inet_aton(lua_tostring(L, -1), &val.imr_interface))
+         luaL_argerror(L, 3, "invalid 'interface' ip address");
+     return opt_set(L, ps, level, name, (char *) &val, sizeof(val));
+ }
+@@ -272,14 +282,14 @@ static int opt_ip6_setmembership(lua_State *L, p_socket ps, int level, int name)
+     if (!lua_istable(L, 3)) auxiliar_typeerror(L,3,lua_typename(L, LUA_TTABLE));
+     lua_pushstring(L, "multiaddr");
+     lua_gettable(L, 3);
+-    if (!lua_isstring(L, -1)) 
++    if (!lua_isstring(L, -1))
+         luaL_argerror(L, 3, "string 'multiaddr' field expected");
+-    if (!inet_pton(AF_INET6, lua_tostring(L, -1), &val.ipv6mr_multiaddr)) 
++    if (!inet_pton(AF_INET6, lua_tostring(L, -1), &val.ipv6mr_multiaddr))
+         luaL_argerror(L, 3, "invalid 'multiaddr' ip address");
+     lua_pushstring(L, "interface");
+     lua_gettable(L, 3);
+     /* By default we listen to interface on default route
+-     * (sigh). However, interface= can override it. We should 
++     * (sigh). However, interface= can override it. We should
+      * support either number, or name for it. Waiting for
+      * windows port of if_nametoindex */
+     if (!lua_isnil(L, -1)) {
+@@ -291,7 +301,7 @@ static int opt_ip6_setmembership(lua_State *L, p_socket ps, int level, int name)
+     return opt_set(L, ps, level, name, (char *) &val, sizeof(val));
+ }
+ 
+-static 
++static
+ int opt_get(lua_State *L, p_socket ps, int level, int name, void *val, int* len)
+ {
+     socklen_t socklen = *len;
+@@ -304,7 +314,7 @@ int opt_get(lua_State *L, p_socket ps, int level, int name, void *val, int* len)
+     return 0;
+ }
+ 
+-static 
++static
+ int opt_set(lua_State *L, p_socket ps, int level, int name, void *val, int len)
+ {
+     if (setsockopt(*ps, level, name, (char *) val, len) < 0) {
+diff --git a/src/options.h b/src/options.h
+index 5657a06..19ba0df 100644
+--- a/src/options.h
++++ b/src/options.h
+@@ -21,7 +21,6 @@ typedef t_opt *p_opt;
+ /* supported options for setoption */
+ int opt_set_dontroute(lua_State *L, p_socket ps);
+ int opt_set_broadcast(lua_State *L, p_socket ps);
+-int opt_set_reuseaddr(lua_State *L, p_socket ps);
+ int opt_set_tcp_nodelay(lua_State *L, p_socket ps);
+ int opt_set_keepalive(lua_State *L, p_socket ps);
+ int opt_set_linger(lua_State *L, p_socket ps);
+@@ -40,18 +39,21 @@ int opt_set_ip6_drop_membersip(lua_State *L, p_socket ps);
+ int opt_set_ip6_v6only(lua_State *L, p_socket ps);
+ 
+ /* supported options for getoption */
++int opt_get_dontroute(lua_State *L, p_socket ps);
++int opt_get_broadcast(lua_State *L, p_socket ps);
+ int opt_get_reuseaddr(lua_State *L, p_socket ps);
++int opt_get_reuseport(lua_State *L, p_socket ps);
+ int opt_get_tcp_nodelay(lua_State *L, p_socket ps);
+ int opt_get_keepalive(lua_State *L, p_socket ps);
+ int opt_get_linger(lua_State *L, p_socket ps);
+-int opt_get_reuseaddr(lua_State *L, p_socket ps);
+ int opt_get_ip_multicast_loop(lua_State *L, p_socket ps);
+ int opt_get_ip_multicast_if(lua_State *L, p_socket ps);
+ int opt_get_error(lua_State *L, p_socket ps);
+ int opt_get_ip6_multicast_loop(lua_State *L, p_socket ps);
+ int opt_get_ip6_multicast_hops(lua_State *L, p_socket ps);
+ int opt_get_ip6_unicast_hops(lua_State *L, p_socket ps);
+-int opt_get_ip6_v6only(lua_State *L, p_socket ps); 
++int opt_get_ip6_v6only(lua_State *L, p_socket ps);
++int opt_get_reuseport(lua_State *L, p_socket ps);
+ 
+ /* invokes the appropriate option handler */
+ int opt_meth_setoption(lua_State *L, p_opt opt, p_socket ps);
+diff --git a/src/pierror.h b/src/pierror.h
+new file mode 100644
+index 0000000..cb773ab
+--- /dev/null
++++ b/src/pierror.h
+@@ -0,0 +1,28 @@
++#ifndef PIERROR_H
++#define PIERROR_H
++/*=========================================================================*\
++* Error messages
++* Defines platform independent error messages
++\*=========================================================================*/
++
++#define PIE_HOST_NOT_FOUND "host not found"
++#define PIE_ADDRINUSE      "address already in use"
++#define PIE_ISCONN         "already connected"
++#define PIE_ACCESS         "permission denied"
++#define PIE_CONNREFUSED    "connection refused"
++#define PIE_CONNABORTED    "closed"
++#define PIE_CONNRESET      "closed"
++#define PIE_TIMEDOUT       "timeout"
++#define PIE_AGAIN          "temporary failure in name resolution"
++#define PIE_BADFLAGS       "invalid value for ai_flags"
++#define PIE_BADHINTS       "invalid value for hints"
++#define PIE_FAIL           "non-recoverable failure in name resolution"
++#define PIE_FAMILY         "ai_family not supported"
++#define PIE_MEMORY         "memory allocation failure"
++#define PIE_NONAME         "host or service not provided, or not known"
++#define PIE_OVERFLOW       "argument buffer overflow"
++#define PIE_PROTOCOL       "resolved protocol is unknown"
++#define PIE_SERVICE        "service not supported for socket type"
++#define PIE_SOCKTYPE       "ai_socktype not supported"
++
++#endif
+diff --git a/src/select.c b/src/select.c
+index fafaa62..9d133b7 100644
+--- a/src/select.c
++++ b/src/select.c
+@@ -6,6 +6,7 @@
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
++#include "compat.h"
+ 
+ #include "socket.h"
+ #include "timeout.h"
+@@ -16,10 +17,10 @@
+ \*=========================================================================*/
+ static t_socket getfd(lua_State *L);
+ static int dirty(lua_State *L);
+-static void collect_fd(lua_State *L, int tab, int itab, 
++static void collect_fd(lua_State *L, int tab, int itab,
+         fd_set *set, t_socket *max_fd);
+ static int check_dirty(lua_State *L, int tab, int dtab, fd_set *set);
+-static void return_fd(lua_State *L, fd_set *set, t_socket max_fd, 
++static void return_fd(lua_State *L, fd_set *set, t_socket max_fd,
+         int itab, int tab, int start);
+ static void make_assoc(lua_State *L, int tab);
+ static int global_select(lua_State *L);
+@@ -38,13 +39,12 @@ static luaL_Reg func[] = {
+ \*-------------------------------------------------------------------------*/
+ int select_open(lua_State *L) {
+     lua_pushstring(L, "_SETSIZE");
+-    lua_pushnumber(L, FD_SETSIZE);
++    lua_pushinteger(L, FD_SETSIZE);
++    lua_rawset(L, -3);
++    lua_pushstring(L, "_SOCKETINVALID");
++    lua_pushinteger(L, SOCKET_INVALID);
+     lua_rawset(L, -3);
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+     luaL_setfuncs(L, func, 0);
+-#else
+-    luaL_openlib(L, NULL, func, 0);
+-#endif
+     return 0;
+ }
+ 
+@@ -98,10 +98,10 @@ static t_socket getfd(lua_State *L) {
+         lua_pushvalue(L, -2);
+         lua_call(L, 1, 1);
+         if (lua_isnumber(L, -1)) {
+-            double numfd = lua_tonumber(L, -1); 
++            double numfd = lua_tonumber(L, -1);
+             fd = (numfd >= 0.0)? (t_socket) numfd: SOCKET_INVALID;
+         }
+-    } 
++    }
+     lua_pop(L, 1);
+     return fd;
+ }
+@@ -114,12 +114,12 @@ static int dirty(lua_State *L) {
+         lua_pushvalue(L, -2);
+         lua_call(L, 1, 1);
+         is = lua_toboolean(L, -1);
+-    } 
++    }
+     lua_pop(L, 1);
+     return is;
+ }
+ 
+-static void collect_fd(lua_State *L, int tab, int itab, 
++static void collect_fd(lua_State *L, int tab, int itab,
+         fd_set *set, t_socket *max_fd) {
+     int i = 1, n = 0;
+     /* nil is the same as an empty table */
+@@ -139,16 +139,16 @@ static void collect_fd(lua_State *L, int tab, int itab,
+         if (fd != SOCKET_INVALID) {
+             /* make sure we don't overflow the fd_set */
+ #ifdef _WIN32
+-            if (n >= FD_SETSIZE) 
++            if (n >= FD_SETSIZE)
+                 luaL_argerror(L, tab, "too many sockets");
+ #else
+-            if (fd >= FD_SETSIZE) 
++            if (fd >= FD_SETSIZE)
+                 luaL_argerror(L, tab, "descriptor too large for set size");
+ #endif
+             FD_SET(fd, set);
+             n++;
+             /* keep track of the largest descriptor so far */
+-            if (*max_fd == SOCKET_INVALID || *max_fd < fd) 
++            if (*max_fd == SOCKET_INVALID || *max_fd < fd)
+                 *max_fd = fd;
+             /* make sure we can map back from descriptor to the object */
+             lua_pushnumber(L, (lua_Number) fd);
+@@ -162,9 +162,9 @@ static void collect_fd(lua_State *L, int tab, int itab,
+ 
+ static int check_dirty(lua_State *L, int tab, int dtab, fd_set *set) {
+     int ndirty = 0, i = 1;
+-    if (lua_isnil(L, tab)) 
++    if (lua_isnil(L, tab))
+         return 0;
+-    for ( ;; ) { 
++    for ( ;; ) {
+         t_socket fd;
+         lua_pushnumber(L, i);
+         lua_gettable(L, tab);
+@@ -185,7 +185,7 @@ static int check_dirty(lua_State *L, int tab, int dtab, fd_set *set) {
+     return ndirty;
+ }
+ 
+-static void return_fd(lua_State *L, fd_set *set, t_socket max_fd, 
++static void return_fd(lua_State *L, fd_set *set, t_socket max_fd,
+         int itab, int tab, int start) {
+     t_socket fd;
+     for (fd = 0; fd < max_fd; fd++) {
+diff --git a/src/serial.c b/src/serial.c
+index 583d4e5..7bdb21c 100644
+--- a/src/serial.c
++++ b/src/serial.c
+@@ -2,7 +2,7 @@
+ * Serial stream
+ * LuaSocket toolkit
+ \*=========================================================================*/
+-#include  
++#include 
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
+@@ -11,7 +11,7 @@
+ #include "socket.h"
+ #include "options.h"
+ #include "unix.h"
+-#include  
++#include 
+ 
+ /*
+ Reuses userdata definition from unix.h, since it is useful for all
+@@ -54,15 +54,6 @@ static luaL_Reg serial_methods[] = {
+     {NULL,          NULL}
+ };
+ 
+-/* our socket creation function */
+-/* this is an ad-hoc module that returns a single function 
+- * as such, do not include other functions in this array. */
+-static luaL_Reg func[] = {
+-    {"serial", global_create},
+-    {NULL,          NULL}
+-};
+-
+-
+ /*-------------------------------------------------------------------------*\
+ * Initializes module
+ \*-------------------------------------------------------------------------*/
+@@ -71,14 +62,7 @@ LUASOCKET_API int luaopen_socket_serial(lua_State *L) {
+     auxiliar_newclass(L, "serial{client}", serial_methods);
+     /* create class groups */
+     auxiliar_add2group(L, "serial{client}", "serial{any}");
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+-    lua_pushcfunction(L, global_create);
+-    (void) func;
+-#else
+-    /* set function into socket namespace */
+-    luaL_openlib(L, "socket", func, 0);
+     lua_pushcfunction(L, global_create);
+-#endif
+     return 1;
+ }
+ 
+@@ -120,7 +104,7 @@ static int meth_getfd(lua_State *L) {
+ /* this is very dangerous, but can be handy for those that are brave enough */
+ static int meth_setfd(lua_State *L) {
+     p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1);
+-    un->sock = (t_socket) luaL_checknumber(L, 2); 
++    un->sock = (t_socket) luaL_checknumber(L, 2);
+     return 0;
+ }
+ 
+@@ -131,7 +115,7 @@ static int meth_dirty(lua_State *L) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Closes socket used by object 
++* Closes socket used by object
+ \*-------------------------------------------------------------------------*/
+ static int meth_close(lua_State *L)
+ {
+@@ -156,7 +140,7 @@ static int meth_settimeout(lua_State *L) {
+ 
+ 
+ /*-------------------------------------------------------------------------*\
+-* Creates a serial object 
++* Creates a serial object
+ \*-------------------------------------------------------------------------*/
+ static int global_create(lua_State *L) {
+     const char* path = luaL_checkstring(L, 1);
+@@ -180,7 +164,7 @@ static int global_create(lua_State *L) {
+     /* initialize remaining structure fields */
+     socket_setnonblocking(&sock);
+     un->sock = sock;
+-    io_init(&un->io, (p_send) socket_write, (p_recv) socket_read, 
++    io_init(&un->io, (p_send) socket_write, (p_recv) socket_read,
+             (p_error) socket_ioerror, &un->sock);
+     timeout_init(&un->tm, -1, -1);
+     buffer_init(&un->buf, &un->io, &un->tm);
+diff --git a/src/socket.lua b/src/socket.lua
+index 3913e6f..d1c0b16 100644
+--- a/src/socket.lua
++++ b/src/socket.lua
+@@ -32,23 +32,23 @@ function _M.bind(host, port, backlog)
+     err = "no info on address"
+     for i, alt in base.ipairs(addrinfo) do
+         if alt.family == "inet" then
+-            sock, err = socket.tcp()
++            sock, err = socket.tcp4()
+         else
+             sock, err = socket.tcp6()
+         end
+         if not sock then return nil, err end
+         sock:setoption("reuseaddr", true)
+         res, err = sock:bind(alt.addr, port)
+-        if not res then 
++        if not res then
+             sock:close()
+-        else 
++        else
+             res, err = sock:listen(backlog)
+-            if not res then 
++            if not res then
+                 sock:close()
+             else
+                 return sock
+             end
+-        end 
++        end
+     end
+     return nil, err
+ end
+diff --git a/src/tcp.c b/src/tcp.c
+index 6594bda..ef9ee6f 100644
+--- a/src/tcp.c
++++ b/src/tcp.c
+@@ -6,6 +6,7 @@
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
++#include "compat.h"
+ 
+ #include "auxiliar.h"
+ #include "socket.h"
+@@ -17,6 +18,7 @@
+ * Internal function prototypes
+ \*=========================================================================*/
+ static int global_create(lua_State *L);
++static int global_create4(lua_State *L);
+ static int global_create6(lua_State *L);
+ static int global_connect(lua_State *L);
+ static int meth_connect(lua_State *L);
+@@ -34,6 +36,7 @@ static int meth_accept(lua_State *L);
+ static int meth_close(lua_State *L);
+ static int meth_getoption(lua_State *L);
+ static int meth_setoption(lua_State *L);
++static int meth_gettimeout(lua_State *L);
+ static int meth_settimeout(lua_State *L);
+ static int meth_getfd(lua_State *L);
+ static int meth_setfd(lua_State *L);
+@@ -63,6 +66,7 @@ static luaL_Reg tcp_methods[] = {
+     {"setpeername", meth_connect},
+     {"setsockname", meth_bind},
+     {"settimeout",  meth_settimeout},
++    {"gettimeout",  meth_gettimeout},
+     {"shutdown",    meth_shutdown},
+     {NULL,          NULL}
+ };
+@@ -71,6 +75,7 @@ static luaL_Reg tcp_methods[] = {
+ static t_opt optget[] = {
+     {"keepalive",   opt_get_keepalive},
+     {"reuseaddr",   opt_get_reuseaddr},
++    {"reuseport",   opt_get_reuseport},
+     {"tcp-nodelay", opt_get_tcp_nodelay},
+     {"linger",      opt_get_linger},
+     {"error",       opt_get_error},
+@@ -80,6 +85,7 @@ static t_opt optget[] = {
+ static t_opt optset[] = {
+     {"keepalive",   opt_set_keepalive},
+     {"reuseaddr",   opt_set_reuseaddr},
++    {"reuseport",   opt_set_reuseport},
+     {"tcp-nodelay", opt_set_tcp_nodelay},
+     {"ipv6-v6only", opt_set_ip6_v6only},
+     {"linger",      opt_set_linger},
+@@ -89,6 +95,7 @@ static t_opt optset[] = {
+ /* functions in library namespace */
+ static luaL_Reg func[] = {
+     {"tcp", global_create},
++    {"tcp4", global_create4},
+     {"tcp6", global_create6},
+     {"connect", global_connect},
+     {NULL, NULL}
+@@ -108,11 +115,7 @@ int tcp_open(lua_State *L)
+     auxiliar_add2group(L, "tcp{client}", "tcp{any}");
+     auxiliar_add2group(L, "tcp{server}", "tcp{any}");
+     /* define library functions */
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+     luaL_setfuncs(L, func, 0);
+-#else
+-    luaL_openlib(L, NULL, func, 0);
+-#endif
+     return 0;
+ }
+ 
+@@ -216,8 +219,7 @@ static int meth_accept(lua_State *L)
+ /*-------------------------------------------------------------------------*\
+ * Binds an object to an address
+ \*-------------------------------------------------------------------------*/
+-static int meth_bind(lua_State *L)
+-{
++static int meth_bind(lua_State *L) {
+     p_tcp tcp = (p_tcp) auxiliar_checkclass(L, "tcp{master}", 1);
+     const char *address =  luaL_checkstring(L, 2);
+     const char *port = luaL_checkstring(L, 3);
+@@ -227,7 +229,7 @@ static int meth_bind(lua_State *L)
+     bindhints.ai_socktype = SOCK_STREAM;
+     bindhints.ai_family = tcp->family;
+     bindhints.ai_flags = AI_PASSIVE;
+-    err = inet_trybind(&tcp->sock, address, port, &bindhints);
++    err = inet_trybind(&tcp->sock, &tcp->family, address, port, &bindhints);
+     if (err) {
+         lua_pushnil(L);
+         lua_pushstring(L, err);
+@@ -240,8 +242,7 @@ static int meth_bind(lua_State *L)
+ /*-------------------------------------------------------------------------*\
+ * Turns a master tcp object into a client object.
+ \*-------------------------------------------------------------------------*/
+-static int meth_connect(lua_State *L)
+-{
++static int meth_connect(lua_State *L) {
+     p_tcp tcp = (p_tcp) auxiliar_checkgroup(L, "tcp{any}", 1);
+     const char *address =  luaL_checkstring(L, 2);
+     const char *port = luaL_checkstring(L, 3);
+@@ -252,7 +253,7 @@ static int meth_connect(lua_State *L)
+     /* make sure we try to connect only to the same family */
+     connecthints.ai_family = tcp->family;
+     timeout_markstart(&tcp->tm);
+-    err = inet_tryconnect(&tcp->sock, &tcp->family, address, port, 
++    err = inet_tryconnect(&tcp->sock, &tcp->family, address, port,
+         &tcp->tm, &connecthints);
+     /* have to set the class even if it failed due to non-blocking connects */
+     auxiliar_setclass(L, "tcp{client}", 1);
+@@ -282,9 +283,12 @@ static int meth_close(lua_State *L)
+ static int meth_getfamily(lua_State *L)
+ {
+     p_tcp tcp = (p_tcp) auxiliar_checkgroup(L, "tcp{any}", 1);
+-    if (tcp->family == PF_INET6) {
++    if (tcp->family == AF_INET6) {
+         lua_pushliteral(L, "inet6");
+         return 1;
++    } else if (tcp->family == AF_INET) {
++        lua_pushliteral(L, "inet4");
++        return 1;
+     } else {
+         lua_pushliteral(L, "inet4");
+         return 1;
+@@ -348,6 +352,12 @@ static int meth_settimeout(lua_State *L)
+     return timeout_meth_settimeout(L, &tcp->tm);
+ }
+ 
++static int meth_gettimeout(lua_State *L)
++{
++    p_tcp tcp = (p_tcp) auxiliar_checkgroup(L, "tcp{any}", 1);
++    return timeout_meth_gettimeout(L, &tcp->tm);
++}
++
+ /*=========================================================================*\
+ * Library functions
+ \*=========================================================================*/
+@@ -355,37 +365,36 @@ static int meth_settimeout(lua_State *L)
+ * Creates a master tcp object
+ \*-------------------------------------------------------------------------*/
+ static int tcp_create(lua_State *L, int family) {
+-    t_socket sock;
+-    const char *err = inet_trycreate(&sock, family, SOCK_STREAM);
+-    /* try to allocate a system socket */
+-    if (!err) {
+-        /* allocate tcp object */
+-        p_tcp tcp = (p_tcp) lua_newuserdata(L, sizeof(t_tcp));
+-        memset(tcp, 0, sizeof(t_tcp));
+-        /* set its type as master object */
+-        auxiliar_setclass(L, "tcp{master}", -1);
+-        /* initialize remaining structure fields */
+-        socket_setnonblocking(&sock);
+-        if (family == PF_INET6) {
+-            int yes = 1;
+-            setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
+-                (void *)&yes, sizeof(yes));
++    p_tcp tcp = (p_tcp) lua_newuserdata(L, sizeof(t_tcp));
++    memset(tcp, 0, sizeof(t_tcp));
++    /* set its type as master object */
++    auxiliar_setclass(L, "tcp{master}", -1);
++    /* if family is AF_UNSPEC, we leave the socket invalid and
++     * store AF_UNSPEC into family. This will allow it to later be
++     * replaced with an AF_INET6 or AF_INET socket upon first use. */
++    tcp->sock = SOCKET_INVALID;
++    tcp->family = family;
++    io_init(&tcp->io, (p_send) socket_send, (p_recv) socket_recv,
++            (p_error) socket_ioerror, &tcp->sock);
++    timeout_init(&tcp->tm, -1, -1);
++    buffer_init(&tcp->buf, &tcp->io, &tcp->tm);
++    if (family != AF_UNSPEC) {
++        const char *err = inet_trycreate(&tcp->sock, family, SOCK_STREAM, 0);
++        if (err != NULL) {
++            lua_pushnil(L);
++            lua_pushstring(L, err);
++            return 2;
+         }
+-        tcp->sock = sock;
+-        io_init(&tcp->io, (p_send) socket_send, (p_recv) socket_recv,
+-                (p_error) socket_ioerror, &tcp->sock);
+-        timeout_init(&tcp->tm, -1, -1);
+-        buffer_init(&tcp->buf, &tcp->io, &tcp->tm);
+-        tcp->family = family;
+-        return 1;
+-    } else {
+-        lua_pushnil(L);
+-        lua_pushstring(L, err);
+-        return 2;
++        socket_setnonblocking(&tcp->sock);
+     }
++    return 1;
+ }
+ 
+ static int global_create(lua_State *L) {
++    return tcp_create(L, AF_UNSPEC);
++}
++
++static int global_create4(lua_State *L) {
+     return tcp_create(L, AF_INET);
+ }
+ 
+@@ -393,53 +402,6 @@ static int global_create6(lua_State *L) {
+     return tcp_create(L, AF_INET6);
+ }
+ 
+-#if 0
+-static const char *tryconnect6(const char *remoteaddr, const char *remoteserv,
+-    struct addrinfo *connecthints, p_tcp tcp) {
+-    struct addrinfo *iterator = NULL, *resolved = NULL;
+-    const char *err = NULL;
+-    /* try resolving */
+-    err = socket_gaistrerror(getaddrinfo(remoteaddr, remoteserv,
+-                connecthints, &resolved));
+-    if (err != NULL) {
+-        if (resolved) freeaddrinfo(resolved);
+-        return err;
+-    }
+-    /* iterate over all returned addresses trying to connect */
+-    for (iterator = resolved; iterator; iterator = iterator->ai_next) {
+-        p_timeout tm = timeout_markstart(&tcp->tm);
+-        /* create new socket if necessary. if there was no
+-         * bind, we need to create one for every new family
+-         * that shows up while iterating. if there was a
+-         * bind, all families will be the same and we will
+-         * not enter this branch. */
+-        if (tcp->family != iterator->ai_family) {
+-            socket_destroy(&tcp->sock);
+-            err = socket_strerror(socket_create(&tcp->sock,
+-                iterator->ai_family, iterator->ai_socktype,
+-                iterator->ai_protocol));
+-            if (err != NULL) {
+-                freeaddrinfo(resolved);
+-                return err;
+-            }
+-            tcp->family = iterator->ai_family;
+-            /* all sockets initially non-blocking */
+-            socket_setnonblocking(&tcp->sock);
+-        }
+-        /* finally try connecting to remote address */
+-        err = socket_strerror(socket_connect(&tcp->sock,
+-            (SA *) iterator->ai_addr,
+-            (socklen_t) iterator->ai_addrlen, tm));
+-        /* if success, break out of loop */
+-        if (err == NULL) break;
+-    }
+-
+-    freeaddrinfo(resolved);
+-    /* here, if err is set, we failed */
+-    return err;
+-}
+-#endif
+-
+ static int global_connect(lua_State *L) {
+     const char *remoteaddr = luaL_checkstring(L, 1);
+     const char *remoteserv = luaL_checkstring(L, 2);
+@@ -456,26 +418,26 @@ static int global_connect(lua_State *L) {
+     timeout_init(&tcp->tm, -1, -1);
+     buffer_init(&tcp->buf, &tcp->io, &tcp->tm);
+     tcp->sock = SOCKET_INVALID;
+-    tcp->family = PF_UNSPEC;
++    tcp->family = AF_UNSPEC;
+     /* allow user to pick local address and port */
+     memset(&bindhints, 0, sizeof(bindhints));
+     bindhints.ai_socktype = SOCK_STREAM;
+     bindhints.ai_family = family;
+     bindhints.ai_flags = AI_PASSIVE;
+     if (localaddr) {
+-        err = inet_trybind(&tcp->sock, localaddr, localserv, &bindhints);
++        err = inet_trybind(&tcp->sock, &tcp->family, localaddr,
++            localserv, &bindhints);
+         if (err) {
+             lua_pushnil(L);
+             lua_pushstring(L, err);
+             return 2;
+         }
+-        tcp->family = bindhints.ai_family;
+     }
+     /* try to connect to remote address and port */
+     memset(&connecthints, 0, sizeof(connecthints));
+     connecthints.ai_socktype = SOCK_STREAM;
+     /* make sure we try to connect only to the same family */
+-    connecthints.ai_family = bindhints.ai_family;
++    connecthints.ai_family = tcp->family;
+     err = inet_tryconnect(&tcp->sock, &tcp->family, remoteaddr, remoteserv,
+          &tcp->tm, &connecthints);
+     if (err) {
+diff --git a/src/timeout.c b/src/timeout.c
+index bdd5e1c..5a601d5 100644
+--- a/src/timeout.c
++++ b/src/timeout.c
+@@ -8,6 +8,7 @@
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
++#include "compat.h"
+ 
+ #include "auxiliar.h"
+ #include "timeout.h"
+@@ -52,7 +53,7 @@ void timeout_init(p_timeout tm, double block, double total) {
+ 
+ /*-------------------------------------------------------------------------*\
+ * Determines how much time we have left for the next system call,
+-* if the previous call was successful 
++* if the previous call was successful
+ * Input
+ *   tm: timeout control structure
+ * Returns
+@@ -107,7 +108,7 @@ double timeout_getretry(p_timeout tm) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Marks the operation start time in structure 
++* Marks the operation start time in structure
+ * Input
+ *   tm: timeout control structure
+ \*-------------------------------------------------------------------------*/
+@@ -117,7 +118,7 @@ p_timeout timeout_markstart(p_timeout tm) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Gets time in s, relative to January 1, 1970 (UTC) 
++* Gets time in s, relative to January 1, 1970 (UTC)
+ * Returns
+ *   time in s.
+ \*-------------------------------------------------------------------------*/
+@@ -144,11 +145,7 @@ double timeout_gettime(void) {
+ * Initializes module
+ \*-------------------------------------------------------------------------*/
+ int timeout_open(lua_State *L) {
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+     luaL_setfuncs(L, func, 0);
+-#else
+-    luaL_openlib(L, NULL, func, 0);
+-#endif
+     return 0;
+ }
+ 
+@@ -163,7 +160,7 @@ int timeout_meth_settimeout(lua_State *L, p_timeout tm) {
+     const char *mode = luaL_optstring(L, 3, "b");
+     switch (*mode) {
+         case 'b':
+-            tm->block = t; 
++            tm->block = t;
+             break;
+         case 'r': case 't':
+             tm->total = t;
+@@ -176,6 +173,16 @@ int timeout_meth_settimeout(lua_State *L, p_timeout tm) {
+     return 1;
+ }
+ 
++/*-------------------------------------------------------------------------*\
++* Gets timeout values for IO operations
++* Lua Output: block, total
++\*-------------------------------------------------------------------------*/
++int timeout_meth_gettimeout(lua_State *L, p_timeout tm) {
++    lua_pushnumber(L, tm->block);
++    lua_pushnumber(L, tm->total);
++    return 2;
++}
++
+ /*=========================================================================*\
+ * Test support functions
+ \*=========================================================================*/
+diff --git a/src/timeout.h b/src/timeout.h
+index 6715ca7..af90231 100644
+--- a/src/timeout.h
++++ b/src/timeout.h
+@@ -22,6 +22,7 @@ p_timeout timeout_markstart(p_timeout tm);
+ double timeout_getstart(p_timeout tm);
+ double timeout_gettime(void);
+ int timeout_meth_settimeout(lua_State *L, p_timeout tm);
++int timeout_meth_gettimeout(lua_State *L, p_timeout tm);
+ 
+ #define timeout_iszero(tm)   ((tm)->block == 0.0)
+ 
+diff --git a/src/tp.lua b/src/tp.lua
+index cbeff56..328cbab 100644
+--- a/src/tp.lua
++++ b/src/tp.lua
+@@ -74,7 +74,7 @@ function metat.__index:command(cmd, arg)
+ end
+ 
+ function metat.__index:sink(snk, pat)
+-    local chunk, err = c:receive(pat)
++    local chunk, err = self.c:receive(pat)
+     return snk(chunk, err)
+ end
+ 
+diff --git a/src/udp.c b/src/udp.c
+index a9f2393..ec97252 100644
+--- a/src/udp.c
++++ b/src/udp.c
+@@ -7,6 +7,7 @@
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
++#include "compat.h"
+ 
+ #include "auxiliar.h"
+ #include "socket.h"
+@@ -26,6 +27,7 @@
+ * Internal function prototypes
+ \*=========================================================================*/
+ static int global_create(lua_State *L);
++static int global_create4(lua_State *L);
+ static int global_create6(lua_State *L);
+ static int meth_send(lua_State *L);
+ static int meth_sendto(lua_State *L);
+@@ -34,6 +36,7 @@ static int meth_receivefrom(lua_State *L);
+ static int meth_getfamily(lua_State *L);
+ static int meth_getsockname(lua_State *L);
+ static int meth_getpeername(lua_State *L);
++static int meth_gettimeout(lua_State *L);
+ static int meth_setsockname(lua_State *L);
+ static int meth_setpeername(lua_State *L);
+ static int meth_close(lua_State *L);
+@@ -64,6 +67,7 @@ static luaL_Reg udp_methods[] = {
+     {"setpeername", meth_setpeername},
+     {"setsockname", meth_setsockname},
+     {"settimeout",  meth_settimeout},
++    {"gettimeout",  meth_gettimeout},
+     {NULL,          NULL}
+ };
+ 
+@@ -89,6 +93,10 @@ static t_opt optset[] = {
+ 
+ /* socket options for getoption */
+ static t_opt optget[] = {
++    {"dontroute",            opt_get_dontroute},
++    {"broadcast",            opt_get_broadcast},
++    {"reuseaddr",            opt_get_reuseaddr},
++    {"reuseport",            opt_get_reuseport},
+     {"ip-multicast-if",      opt_get_ip_multicast_if},
+     {"ip-multicast-loop",    opt_get_ip_multicast_loop},
+     {"error",                opt_get_error},
+@@ -102,6 +110,7 @@ static t_opt optget[] = {
+ /* functions in library namespace */
+ static luaL_Reg func[] = {
+     {"udp", global_create},
++    {"udp4", global_create4},
+     {"udp6", global_create6},
+     {NULL, NULL}
+ };
+@@ -109,8 +118,7 @@ static luaL_Reg func[] = {
+ /*-------------------------------------------------------------------------*\
+ * Initializes module
+ \*-------------------------------------------------------------------------*/
+-int udp_open(lua_State *L)
+-{
++int udp_open(lua_State *L) {
+     /* create classes */
+     auxiliar_newclass(L, "udp{connected}", udp_methods);
+     auxiliar_newclass(L, "udp{unconnected}", udp_methods);
+@@ -120,18 +128,18 @@ int udp_open(lua_State *L)
+     auxiliar_add2group(L, "udp{connected}",   "select{able}");
+     auxiliar_add2group(L, "udp{unconnected}", "select{able}");
+     /* define library functions */
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+     luaL_setfuncs(L, func, 0);
+-#else
+-    luaL_openlib(L, NULL, func, 0);
+-#endif
++    /* export default UDP size */
++    lua_pushliteral(L, "_DATAGRAMSIZE");
++    lua_pushinteger(L, UDP_DATAGRAMSIZE);
++    lua_rawset(L, -3);
+     return 0;
+ }
+ 
+ /*=========================================================================*\
+ * Lua methods
+ \*=========================================================================*/
+-const char *udp_strerror(int err) {
++static const char *udp_strerror(int err) {
+     /* a 'closed' error on an unconnected means the target address was not
+      * accepted by the transport layer */
+     if (err == IO_CLOSED) return "refused";
+@@ -182,7 +190,7 @@ static int meth_sendto(lua_State *L) {
+         return 2;
+     }
+     timeout_markstart(tm);
+-    err = socket_sendto(&udp->sock, data, count, &sent, ai->ai_addr, 
++    err = socket_sendto(&udp->sock, data, count, &sent, ai->ai_addr,
+         (socklen_t) ai->ai_addrlen, tm);
+     freeaddrinfo(ai);
+     if (err != IO_DONE) {
+@@ -199,71 +207,80 @@ static int meth_sendto(lua_State *L) {
+ \*-------------------------------------------------------------------------*/
+ static int meth_receive(lua_State *L) {
+     p_udp udp = (p_udp) auxiliar_checkgroup(L, "udp{any}", 1);
+-    char buffer[UDP_DATAGRAMSIZE];
+-    size_t got, count = (size_t) luaL_optnumber(L, 2, sizeof(buffer));
++    char buf[UDP_DATAGRAMSIZE];
++    size_t got, wanted = (size_t) luaL_optnumber(L, 2, sizeof(buf));
++    char *dgram = wanted > sizeof(buf)? (char *) malloc(wanted): buf;
+     int err;
+     p_timeout tm = &udp->tm;
+-    count = MIN(count, sizeof(buffer));
+     timeout_markstart(tm);
+-    err = socket_recv(&udp->sock, buffer, count, &got, tm);
++    if (!dgram) {
++        lua_pushnil(L);
++        lua_pushliteral(L, "out of memory");
++        return 2;
++    }
++    err = socket_recv(&udp->sock, dgram, wanted, &got, tm);
+     /* Unlike TCP, recv() of zero is not closed, but a zero-length packet. */
+-    if (err == IO_CLOSED)
+-        err = IO_DONE;
+-    if (err != IO_DONE) {
++    if (err != IO_DONE && err != IO_CLOSED) {
+         lua_pushnil(L);
+         lua_pushstring(L, udp_strerror(err));
++        if (wanted > sizeof(buf)) free(dgram);
+         return 2;
+     }
+-    lua_pushlstring(L, buffer, got);
++    lua_pushlstring(L, dgram, got);
++    if (wanted > sizeof(buf)) free(dgram);
+     return 1;
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+ * Receives data and sender from a UDP socket
+ \*-------------------------------------------------------------------------*/
+-static int meth_receivefrom(lua_State *L)
+-{
++static int meth_receivefrom(lua_State *L) {
+     p_udp udp = (p_udp) auxiliar_checkclass(L, "udp{unconnected}", 1);
+-    char buffer[UDP_DATAGRAMSIZE];
+-    size_t got, count = (size_t) luaL_optnumber(L, 2, sizeof(buffer));
+-    int err;
+-    p_timeout tm = &udp->tm;
++    char buf[UDP_DATAGRAMSIZE];
++    size_t got, wanted = (size_t) luaL_optnumber(L, 2, sizeof(buf));
++    char *dgram = wanted > sizeof(buf)? (char *) malloc(wanted): buf;
+     struct sockaddr_storage addr;
+     socklen_t addr_len = sizeof(addr);
+     char addrstr[INET6_ADDRSTRLEN];
+     char portstr[6];
++    int err;
++    p_timeout tm = &udp->tm;
+     timeout_markstart(tm);
+-    count = MIN(count, sizeof(buffer));
+-    err = socket_recvfrom(&udp->sock, buffer, count, &got, (SA *) &addr, 
++    if (!dgram) {
++        lua_pushnil(L);
++        lua_pushliteral(L, "out of memory");
++        return 2;
++    }
++    err = socket_recvfrom(&udp->sock, dgram, wanted, &got, (SA *) &addr,
+             &addr_len, tm);
+     /* Unlike TCP, recv() of zero is not closed, but a zero-length packet. */
+-    if (err == IO_CLOSED)
+-        err = IO_DONE;
+-    if (err != IO_DONE) {
++    if (err != IO_DONE && err != IO_CLOSED) {
+         lua_pushnil(L);
+         lua_pushstring(L, udp_strerror(err));
++        if (wanted > sizeof(buf)) free(dgram);
+         return 2;
+     }
+-    err = getnameinfo((struct sockaddr *)&addr, addr_len, addrstr, 
++    err = getnameinfo((struct sockaddr *)&addr, addr_len, addrstr,
+         INET6_ADDRSTRLEN, portstr, 6, NI_NUMERICHOST | NI_NUMERICSERV);
+ 	if (err) {
+         lua_pushnil(L);
+         lua_pushstring(L, gai_strerror(err));
++        if (wanted > sizeof(buf)) free(dgram);
+         return 2;
+     }
+-    lua_pushlstring(L, buffer, got);
++    lua_pushlstring(L, dgram, got);
+     lua_pushstring(L, addrstr);
+     lua_pushinteger(L, (int) strtol(portstr, (char **) NULL, 10));
++    if (wanted > sizeof(buf)) free(dgram);
+     return 3;
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+ * Returns family as string
+ \*-------------------------------------------------------------------------*/
+-static int meth_getfamily(lua_State *L)
+-{
++static int meth_getfamily(lua_State *L) {
+     p_udp udp = (p_udp) auxiliar_checkgroup(L, "udp{any}", 1);
+-    if (udp->family == PF_INET6) {
++    if (udp->family == AF_INET6) {
+         lua_pushliteral(L, "inet6");
+         return 1;
+     } else {
+@@ -332,6 +349,11 @@ static int meth_settimeout(lua_State *L) {
+     return timeout_meth_settimeout(L, &udp->tm);
+ }
+ 
++static int meth_gettimeout(lua_State *L) {
++    p_udp udp = (p_udp) auxiliar_checkgroup(L, "udp{any}", 1);
++    return timeout_meth_gettimeout(L, &udp->tm);
++}
++
+ /*-------------------------------------------------------------------------*\
+ * Turns a master udp object into a client object.
+ \*-------------------------------------------------------------------------*/
+@@ -348,7 +370,7 @@ static int meth_setpeername(lua_State *L) {
+     /* make sure we try to connect only to the same family */
+     connecthints.ai_family = udp->family;
+     if (connecting) {
+-        err = inet_tryconnect(&udp->sock, &udp->family, address, 
++        err = inet_tryconnect(&udp->sock, &udp->family, address,
+             port, tm, &connecthints);
+         if (err) {
+             lua_pushnil(L);
+@@ -362,7 +384,6 @@ static int meth_setpeername(lua_State *L) {
+         inet_trydisconnect(&udp->sock, udp->family, tm);
+         auxiliar_setclass(L, "udp{unconnected}", 1);
+     }
+-    /* change class to connected or unconnected depending on address */
+     lua_pushnumber(L, 1);
+     return 1;
+ }
+@@ -390,7 +411,7 @@ static int meth_setsockname(lua_State *L) {
+     bindhints.ai_socktype = SOCK_DGRAM;
+     bindhints.ai_family = udp->family;
+     bindhints.ai_flags = AI_PASSIVE;
+-    err = inet_trybind(&udp->sock, address, port, &bindhints);
++    err = inet_trybind(&udp->sock, &udp->family, address, port, &bindhints);
+     if (err) {
+         lua_pushnil(L);
+         lua_pushstring(L, err);
+@@ -407,32 +428,32 @@ static int meth_setsockname(lua_State *L) {
+ * Creates a master udp object
+ \*-------------------------------------------------------------------------*/
+ static int udp_create(lua_State *L, int family) {
+-    t_socket sock;
+-    const char *err = inet_trycreate(&sock, family, SOCK_DGRAM);
+-    /* try to allocate a system socket */
+-    if (!err) {
+-        /* allocate udp object */
+-        p_udp udp = (p_udp) lua_newuserdata(L, sizeof(t_udp));
+-        auxiliar_setclass(L, "udp{unconnected}", -1);
+-        /* initialize remaining structure fields */
+-        socket_setnonblocking(&sock);
+-        if (family == PF_INET6) {
+-            int yes = 1;
+-            setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
+-                (void *)&yes, sizeof(yes));
++    /* allocate udp object */
++    p_udp udp = (p_udp) lua_newuserdata(L, sizeof(t_udp));
++    auxiliar_setclass(L, "udp{unconnected}", -1);
++    /* if family is AF_UNSPEC, we leave the socket invalid and
++     * store AF_UNSPEC into family. This will allow it to later be
++     * replaced with an AF_INET6 or AF_INET socket upon first use. */
++    udp->sock = SOCKET_INVALID;
++    timeout_init(&udp->tm, -1, -1);
++    udp->family = family;
++    if (family != AF_UNSPEC) {
++        const char *err = inet_trycreate(&udp->sock, family, SOCK_DGRAM, 0);
++        if (err != NULL) {
++            lua_pushnil(L);
++            lua_pushstring(L, err);
++            return 2;
+         }
+-        udp->sock = sock;
+-        timeout_init(&udp->tm, -1, -1);
+-        udp->family = family;
+-        return 1;
+-    } else {
+-        lua_pushnil(L);
+-        lua_pushstring(L, err);
+-        return 2;
++        socket_setnonblocking(&udp->sock);
+     }
++    return 1;
+ }
+ 
+ static int global_create(lua_State *L) {
++    return udp_create(L, AF_UNSPEC);
++}
++
++static int global_create4(lua_State *L) {
+     return udp_create(L, AF_INET);
+ }
+ 
+diff --git a/src/udp.h b/src/udp.h
+index 2b831a5..be9b6a5 100644
+--- a/src/udp.h
++++ b/src/udp.h
+@@ -8,7 +8,7 @@
+ * (AF_INET, SOCK_DGRAM).
+ *
+ * Two classes are defined: connected and unconnected. UDP objects are
+-* originally unconnected. They can be "connected" to a given address 
++* originally unconnected. They can be "connected" to a given address
+ * with a call to the setpeername function. The same function can be used to
+ * break the connection.
+ \*=========================================================================*/
+@@ -17,7 +17,6 @@
+ #include "timeout.h"
+ #include "socket.h"
+ 
+-/* can't be larger than wsocket.c MAXCHUNK!!! */
+ #define UDP_DATAGRAMSIZE 8192
+ 
+ typedef struct t_udp_ {
+diff --git a/src/unix.c b/src/unix.c
+index 91aaaf8..5bc3148 100644
+--- a/src/unix.c
++++ b/src/unix.c
+@@ -1,8 +1,8 @@
+ /*=========================================================================*\
+-* Unix domain socket 
++* Unix domain socket
+ * LuaSocket toolkit
+ \*=========================================================================*/
+-#include  
++#include 
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
+@@ -11,7 +11,7 @@
+ #include "socket.h"
+ #include "options.h"
+ #include "unix.h"
+-#include  
++#include 
+ 
+ /*=========================================================================*\
+ * Internal function prototypes
+@@ -68,15 +68,6 @@ static t_opt optset[] = {
+     {NULL,          NULL}
+ };
+ 
+-/* our socket creation function */
+-/* this is an ad-hoc module that returns a single function 
+- * as such, do not include other functions in this array. */
+-static luaL_Reg func[] = {
+-    {"unix", global_create},
+-    {NULL,          NULL}
+-};
+-
+-
+ /*-------------------------------------------------------------------------*\
+ * Initializes module
+ \*-------------------------------------------------------------------------*/
+@@ -89,15 +80,8 @@ int luaopen_socket_unix(lua_State *L) {
+     auxiliar_add2group(L, "unix{master}", "unix{any}");
+     auxiliar_add2group(L, "unix{client}", "unix{any}");
+     auxiliar_add2group(L, "unix{server}", "unix{any}");
+-#if LUA_VERSION_NUM > 501 && !defined(LUA_COMPAT_MODULE)
+-    lua_pushcfunction(L, global_create);
+-    (void) func;
+-#else
+-    /* set function into socket namespace */
+-    luaL_openlib(L, "socket", func, 0);
+-    lua_pushcfunction(L, global_create);
+-#endif
+     /* return the function instead of the 'socket' table */
++    lua_pushcfunction(L, global_create);
+     return 1;
+ }
+ 
+@@ -147,7 +131,7 @@ static int meth_getfd(lua_State *L) {
+ /* this is very dangerous, but can be handy for those that are brave enough */
+ static int meth_setfd(lua_State *L) {
+     p_unix un = (p_unix) auxiliar_checkgroup(L, "unix{any}", 1);
+-    un->sock = (t_socket) luaL_checknumber(L, 2); 
++    un->sock = (t_socket) luaL_checknumber(L, 2);
+     return 0;
+ }
+ 
+@@ -158,8 +142,8 @@ static int meth_dirty(lua_State *L) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Waits for and returns a client object attempting connection to the 
+-* server object 
++* Waits for and returns a client object attempting connection to the
++* server object
+ \*-------------------------------------------------------------------------*/
+ static int meth_accept(lua_State *L) {
+     p_unix server = (p_unix) auxiliar_checkclass(L, "unix{server}", 1);
+@@ -173,20 +157,20 @@ static int meth_accept(lua_State *L) {
+         /* initialize structure fields */
+         socket_setnonblocking(&sock);
+         clnt->sock = sock;
+-        io_init(&clnt->io, (p_send)socket_send, (p_recv)socket_recv, 
++        io_init(&clnt->io, (p_send)socket_send, (p_recv)socket_recv,
+                 (p_error) socket_ioerror, &clnt->sock);
+         timeout_init(&clnt->tm, -1, -1);
+         buffer_init(&clnt->buf, &clnt->io, &clnt->tm);
+         return 1;
+     } else {
+-        lua_pushnil(L); 
++        lua_pushnil(L);
+         lua_pushstring(L, socket_strerror(err));
+         return 2;
+     }
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Binds an object to an address 
++* Binds an object to an address
+ \*-------------------------------------------------------------------------*/
+ static const char *unix_trybind(p_unix un, const char *path) {
+     struct sockaddr_un local;
+@@ -197,16 +181,16 @@ static const char *unix_trybind(p_unix un, const char *path) {
+     strcpy(local.sun_path, path);
+     local.sun_family = AF_UNIX;
+ #ifdef UNIX_HAS_SUN_LEN
+-    local.sun_len = sizeof(local.sun_family) + sizeof(local.sun_len) 
++    local.sun_len = sizeof(local.sun_family) + sizeof(local.sun_len)
+         + len + 1;
+     err = socket_bind(&un->sock, (SA *) &local, local.sun_len);
+ 
+-#else 
+-    err = socket_bind(&un->sock, (SA *) &local, 
++#else
++    err = socket_bind(&un->sock, (SA *) &local,
+             sizeof(local.sun_family) + len);
+ #endif
+     if (err != IO_DONE) socket_destroy(&un->sock);
+-    return socket_strerror(err); 
++    return socket_strerror(err);
+ }
+ 
+ static int meth_bind(lua_State *L) {
+@@ -236,11 +220,11 @@ static const char *unix_tryconnect(p_unix un, const char *path)
+     remote.sun_family = AF_UNIX;
+     timeout_markstart(&un->tm);
+ #ifdef UNIX_HAS_SUN_LEN
+-    remote.sun_len = sizeof(remote.sun_family) + sizeof(remote.sun_len) 
++    remote.sun_len = sizeof(remote.sun_family) + sizeof(remote.sun_len)
+         + len + 1;
+     err = socket_connect(&un->sock, (SA *) &remote, remote.sun_len, &un->tm);
+ #else
+-    err = socket_connect(&un->sock, (SA *) &remote, 
++    err = socket_connect(&un->sock, (SA *) &remote,
+             sizeof(remote.sun_family) + len, &un->tm);
+ #endif
+     if (err != IO_DONE) socket_destroy(&un->sock);
+@@ -264,7 +248,7 @@ static int meth_connect(lua_State *L)
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Closes socket used by object 
++* Closes socket used by object
+ \*-------------------------------------------------------------------------*/
+ static int meth_close(lua_State *L)
+ {
+@@ -319,13 +303,13 @@ static int meth_settimeout(lua_State *L) {
+ * Library functions
+ \*=========================================================================*/
+ /*-------------------------------------------------------------------------*\
+-* Creates a master unix object 
++* Creates a master unix object
+ \*-------------------------------------------------------------------------*/
+ static int global_create(lua_State *L) {
+     t_socket sock;
+     int err = socket_create(&sock, AF_UNIX, SOCK_STREAM, 0);
+     /* try to allocate a system socket */
+-    if (err == IO_DONE) { 
++    if (err == IO_DONE) {
+         /* allocate unix object */
+         p_unix un = (p_unix) lua_newuserdata(L, sizeof(t_unix));
+         /* set its type as master object */
+@@ -333,7 +317,7 @@ static int global_create(lua_State *L) {
+         /* initialize remaining structure fields */
+         socket_setnonblocking(&sock);
+         un->sock = sock;
+-        io_init(&un->io, (p_send) socket_send, (p_recv) socket_recv, 
++        io_init(&un->io, (p_send) socket_send, (p_recv) socket_recv,
+                 (p_error) socket_ioerror, &un->sock);
+         timeout_init(&un->tm, -1, -1);
+         buffer_init(&un->buf, &un->io, &un->tm);
+diff --git a/src/url.lua b/src/url.lua
+index 7809535..fbd93d1 100644
+--- a/src/url.lua
++++ b/src/url.lua
+@@ -219,6 +219,7 @@ end
+ --   corresponding absolute url
+ -----------------------------------------------------------------------------
+ function _M.absolute(base_url, relative_url)
++    local base_parsed
+     if base.type(base_url) == "table" then
+         base_parsed = base_url
+         base_url = _M.build(base_parsed)
+diff --git a/src/usocket.c b/src/usocket.c
+index 096ecd0..8adc573 100644
+--- a/src/usocket.c
++++ b/src/usocket.c
+@@ -4,12 +4,13 @@
+ *
+ * The code is now interrupt-safe.
+ * The penalty of calling select to avoid busy-wait is only paid when
+-* the I/O call fail in the first place. 
++* the I/O call fail in the first place.
+ \*=========================================================================*/
+-#include  
++#include 
+ #include 
+ 
+ #include "socket.h"
++#include "pierror.h"
+ 
+ /*-------------------------------------------------------------------------*\
+ * Wait for readable/writable/connected socket with timeout
+@@ -72,7 +73,7 @@ int socket_waitfd(p_socket ps, int sw, p_timeout tm) {
+ 
+ 
+ /*-------------------------------------------------------------------------*\
+-* Initializes module 
++* Initializes module
+ \*-------------------------------------------------------------------------*/
+ int socket_open(void) {
+     /* instals a handler to ignore sigpipe or it will crash us */
+@@ -81,7 +82,7 @@ int socket_open(void) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Close module 
++* Close module
+ \*-------------------------------------------------------------------------*/
+ int socket_close(void) {
+     return 1;
+@@ -92,7 +93,6 @@ int socket_close(void) {
+ \*-------------------------------------------------------------------------*/
+ void socket_destroy(p_socket ps) {
+     if (*ps != SOCKET_INVALID) {
+-        socket_setblocking(ps);
+         close(*ps);
+         *ps = SOCKET_INVALID;
+     }
+@@ -101,7 +101,7 @@ void socket_destroy(p_socket ps) {
+ /*-------------------------------------------------------------------------*\
+ * Select with timeout control
+ \*-------------------------------------------------------------------------*/
+-int socket_select(t_socket n, fd_set *rfds, fd_set *wfds, fd_set *efds, 
++int socket_select(t_socket n, fd_set *rfds, fd_set *wfds, fd_set *efds,
+         p_timeout tm) {
+     int ret;
+     do {
+@@ -120,8 +120,8 @@ int socket_select(t_socket n, fd_set *rfds, fd_set *wfds, fd_set *efds,
+ \*-------------------------------------------------------------------------*/
+ int socket_create(p_socket ps, int domain, int type, int protocol) {
+     *ps = socket(domain, type, protocol);
+-    if (*ps != SOCKET_INVALID) return IO_DONE; 
+-    else return errno; 
++    if (*ps != SOCKET_INVALID) return IO_DONE;
++    else return errno;
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+@@ -130,29 +130,25 @@ int socket_create(p_socket ps, int domain, int type, int protocol) {
+ int socket_bind(p_socket ps, SA *addr, socklen_t len) {
+     int err = IO_DONE;
+     socket_setblocking(ps);
+-    if (bind(*ps, addr, len) < 0) err = errno; 
++    if (bind(*ps, addr, len) < 0) err = errno;
+     socket_setnonblocking(ps);
+     return err;
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* 
++*
+ \*-------------------------------------------------------------------------*/
+ int socket_listen(p_socket ps, int backlog) {
+-    int err = IO_DONE; 
+-    socket_setblocking(ps);
+-    if (listen(*ps, backlog)) err = errno; 
+-    socket_setnonblocking(ps);
++    int err = IO_DONE;
++    if (listen(*ps, backlog)) err = errno;
+     return err;
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* 
++*
+ \*-------------------------------------------------------------------------*/
+ void socket_shutdown(p_socket ps, int how) {
+-    socket_setblocking(ps);
+     shutdown(*ps, how);
+-    socket_setnonblocking(ps);
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+@@ -166,7 +162,7 @@ int socket_connect(p_socket ps, SA *addr, socklen_t len, p_timeout tm) {
+     do if (connect(*ps, addr, len) == 0) return IO_DONE;
+     while ((err = errno) == EINTR);
+     /* if connection failed immediately, return error code */
+-    if (err != EINPROGRESS && err != EAGAIN) return err; 
++    if (err != EINPROGRESS && err != EAGAIN) return err;
+     /* zero timeout case optimization */
+     if (timeout_iszero(tm)) return IO_TIMEOUT;
+     /* wait until we have the result of the connection attempt or timeout */
+@@ -181,7 +177,7 @@ int socket_connect(p_socket ps, SA *addr, socklen_t len, p_timeout tm) {
+ * Accept with timeout
+ \*-------------------------------------------------------------------------*/
+ int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_t *len, p_timeout tm) {
+-    if (*ps == SOCKET_INVALID) return IO_CLOSED; 
++    if (*ps == SOCKET_INVALID) return IO_CLOSED;
+     for ( ;; ) {
+         int err;
+         if ((*pa = accept(*ps, addr, len)) != SOCKET_INVALID) return IO_DONE;
+@@ -197,7 +193,7 @@ int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_t *len, p_timeout
+ /*-------------------------------------------------------------------------*\
+ * Send with timeout
+ \*-------------------------------------------------------------------------*/
+-int socket_send(p_socket ps, const char *data, size_t count, 
++int socket_send(p_socket ps, const char *data, size_t count,
+         size_t *sent, p_timeout tm)
+ {
+     int err;
+@@ -215,6 +211,8 @@ int socket_send(p_socket ps, const char *data, size_t count,
+         err = errno;
+         /* EPIPE means the connection was closed */
+         if (err == EPIPE) return IO_CLOSED;
++        /* EPROTOTYPE means the connection is being closed (on Yosemite!)*/
++        if (err == EPROTOTYPE) continue;
+         /* we call was interrupted, just try again */
+         if (err == EINTR) continue;
+         /* if failed fatal reason, report error */
+@@ -229,20 +227,21 @@ int socket_send(p_socket ps, const char *data, size_t count,
+ /*-------------------------------------------------------------------------*\
+ * Sendto with timeout
+ \*-------------------------------------------------------------------------*/
+-int socket_sendto(p_socket ps, const char *data, size_t count, size_t *sent, 
++int socket_sendto(p_socket ps, const char *data, size_t count, size_t *sent,
+         SA *addr, socklen_t len, p_timeout tm)
+ {
+     int err;
+     *sent = 0;
+     if (*ps == SOCKET_INVALID) return IO_CLOSED;
+     for ( ;; ) {
+-        long put = (long) sendto(*ps, data, count, 0, addr, len);  
++        long put = (long) sendto(*ps, data, count, 0, addr, len); 
+         if (put >= 0) {
+             *sent = put;
+             return IO_DONE;
+         }
+         err = errno;
+         if (err == EPIPE) return IO_CLOSED;
++        if (err == EPROTOTYPE) continue;
+         if (err == EINTR) continue;
+         if (err != EAGAIN) return err;
+         if ((err = socket_waitfd(ps, WAITFD_W, tm)) != IO_DONE) return err;
+@@ -266,8 +265,8 @@ int socket_recv(p_socket ps, char *data, size_t count, size_t *got, p_timeout tm
+         err = errno;
+         if (taken == 0) return IO_CLOSED;
+         if (err == EINTR) continue;
+-        if (err != EAGAIN) return err; 
+-        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err; 
++        if (err != EAGAIN) return err;
++        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err;
+     }
+     return IO_UNKNOWN;
+ }
+@@ -275,7 +274,7 @@ int socket_recv(p_socket ps, char *data, size_t count, size_t *got, p_timeout tm
+ /*-------------------------------------------------------------------------*\
+ * Recvfrom with timeout
+ \*-------------------------------------------------------------------------*/
+-int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got, 
++int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got,
+         SA *addr, socklen_t *len, p_timeout tm) {
+     int err;
+     *got = 0;
+@@ -289,8 +288,8 @@ int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got,
+         err = errno;
+         if (taken == 0) return IO_CLOSED;
+         if (err == EINTR) continue;
+-        if (err != EAGAIN) return err; 
+-        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err; 
++        if (err != EAGAIN) return err;
++        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err;
+     }
+     return IO_UNKNOWN;
+ }
+@@ -303,7 +302,7 @@ int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got,
+ * with send/recv replaced with write/read. We can't just use write/read
+ * in the socket version, because behaviour when size is zero is different.
+ \*-------------------------------------------------------------------------*/
+-int socket_write(p_socket ps, const char *data, size_t count, 
++int socket_write(p_socket ps, const char *data, size_t count,
+         size_t *sent, p_timeout tm)
+ {
+     int err;
+@@ -321,6 +320,8 @@ int socket_write(p_socket ps, const char *data, size_t count,
+         err = errno;
+         /* EPIPE means the connection was closed */
+         if (err == EPIPE) return IO_CLOSED;
++        /* EPROTOTYPE means the connection is being closed (on Yosemite!)*/
++        if (err == EPROTOTYPE) continue;
+         /* we call was interrupted, just try again */
+         if (err == EINTR) continue;
+         /* if failed fatal reason, report error */
+@@ -349,8 +350,8 @@ int socket_read(p_socket ps, char *data, size_t count, size_t *got, p_timeout tm
+         err = errno;
+         if (taken == 0) return IO_CLOSED;
+         if (err == EINTR) continue;
+-        if (err != EAGAIN) return err; 
+-        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err; 
++        if (err != EAGAIN) return err;
++        if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err;
+     }
+     return IO_UNKNOWN;
+ }
+@@ -374,7 +375,7 @@ void socket_setnonblocking(p_socket ps) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* DNS helpers 
++* DNS helpers
+ \*-------------------------------------------------------------------------*/
+ int socket_gethostbyaddr(const char *addr, socklen_t len, struct hostent **hp) {
+     *hp = gethostbyaddr(addr, len, AF_INET);
+@@ -399,7 +400,7 @@ int socket_gethostbyname(const char *addr, struct hostent **hp) {
+ const char *socket_hoststrerror(int err) {
+     if (err <= 0) return io_strerror(err);
+     switch (err) {
+-        case HOST_NOT_FOUND: return "host not found";
++        case HOST_NOT_FOUND: return PIE_HOST_NOT_FOUND;
+         default: return hstrerror(err);
+     }
+ }
+@@ -407,42 +408,43 @@ const char *socket_hoststrerror(int err) {
+ const char *socket_strerror(int err) {
+     if (err <= 0) return io_strerror(err);
+     switch (err) {
+-        case EADDRINUSE: return "address already in use";
+-        case EISCONN: return "already connected";
+-        case EACCES: return "permission denied";
+-        case ECONNREFUSED: return "connection refused";
+-        case ECONNABORTED: return "closed";
+-        case ECONNRESET: return "closed";
+-        case ETIMEDOUT: return "timeout";
+-        default: return strerror(err);
++        case EADDRINUSE: return PIE_ADDRINUSE;
++        case EISCONN: return PIE_ISCONN;
++        case EACCES: return PIE_ACCESS;
++        case ECONNREFUSED: return PIE_CONNREFUSED;
++        case ECONNABORTED: return PIE_CONNABORTED;
++        case ECONNRESET: return PIE_CONNRESET;
++        case ETIMEDOUT: return PIE_TIMEDOUT;
++        default: {
++            return strerror(err);
++        }
+     }
+ }
+ 
+ const char *socket_ioerror(p_socket ps, int err) {
+     (void) ps;
+     return socket_strerror(err);
+-} 
++}
+ 
+ const char *socket_gaistrerror(int err) {
+-    if (err == 0) return NULL; 
++    if (err == 0) return NULL;
+     switch (err) {
+-        case EAI_AGAIN: return "temporary failure in name resolution";
+-        case EAI_BADFLAGS: return "invalid value for ai_flags";
++        case EAI_AGAIN: return PIE_AGAIN;
++        case EAI_BADFLAGS: return PIE_BADFLAGS;
+ #ifdef EAI_BADHINTS
+-        case EAI_BADHINTS: return "invalid value for hints";
++        case EAI_BADHINTS: return PIE_BADHINTS;
+ #endif
+-        case EAI_FAIL: return "non-recoverable failure in name resolution";
+-        case EAI_FAMILY: return "ai_family not supported";
+-        case EAI_MEMORY: return "memory allocation failure";
+-        case EAI_NONAME: 
+-            return "host or service not provided, or not known";
+-        case EAI_OVERFLOW: return "argument buffer overflow";
++        case EAI_FAIL: return PIE_FAIL;
++        case EAI_FAMILY: return PIE_FAMILY;
++        case EAI_MEMORY: return PIE_MEMORY;
++        case EAI_NONAME: return PIE_NONAME;
++        case EAI_OVERFLOW: return PIE_OVERFLOW;
+ #ifdef EAI_PROTOCOL
+-        case EAI_PROTOCOL: return "resolved protocol is unknown";
++        case EAI_PROTOCOL: return PIE_PROTOCOL;
+ #endif
+-        case EAI_SERVICE: return "service not supported for socket type";
+-        case EAI_SOCKTYPE: return "ai_socktype not supported";
+-        case EAI_SYSTEM: return strerror(errno); 
++        case EAI_SERVICE: return PIE_SERVICE;
++        case EAI_SOCKTYPE: return PIE_SOCKTYPE;
++        case EAI_SYSTEM: return strerror(errno);
+         default: return gai_strerror(err);
+     }
+ }
+diff --git a/src/wsocket.c b/src/wsocket.c
+index b4a4384..8ecb0fc 100644
+--- a/src/wsocket.c
++++ b/src/wsocket.c
+@@ -3,33 +3,34 @@
+ * LuaSocket toolkit
+ *
+ * The penalty of calling select to avoid busy-wait is only paid when
+-* the I/O call fail in the first place. 
++* the I/O call fail in the first place.
+ \*=========================================================================*/
+ #include 
+ 
+ #include "socket.h"
++#include "pierror.h"
+ 
+ /* WinSock doesn't have a strerror... */
+ static const char *wstrerror(int err);
+ 
+ /*-------------------------------------------------------------------------*\
+-* Initializes module 
++* Initializes module
+ \*-------------------------------------------------------------------------*/
+ int socket_open(void) {
+     WSADATA wsaData;
+-    WORD wVersionRequested = MAKEWORD(2, 0); 
++    WORD wVersionRequested = MAKEWORD(2, 0);
+     int err = WSAStartup(wVersionRequested, &wsaData );
+     if (err != 0) return 0;
+     if ((LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0) &&
+         (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)) {
+         WSACleanup();
+-        return 0; 
++        return 0;
+     }
+     return 1;
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* Close module 
++* Close module
+ \*-------------------------------------------------------------------------*/
+ int socket_close(void) {
+     WSACleanup();
+@@ -50,10 +51,10 @@ int socket_waitfd(p_socket ps, int sw, p_timeout tm) {
+     struct timeval tv, *tp = NULL;
+     double t;
+     if (timeout_iszero(tm)) return IO_TIMEOUT;  /* optimize timeout == 0 case */
+-    if (sw & WAITFD_R) { 
+-        FD_ZERO(&rfds); 
++    if (sw & WAITFD_R) {
++        FD_ZERO(&rfds);
+         FD_SET(*ps, &rfds);
+-        rp = &rfds; 
++        rp = &rfds;
+     }
+     if (sw & WAITFD_W) { FD_ZERO(&wfds); FD_SET(*ps, &wfds); wp = &wfds; }
+     if (sw & WAITFD_C) { FD_ZERO(&efds); FD_SET(*ps, &efds); ep = &efds; }
+@@ -72,9 +73,9 @@ int socket_waitfd(p_socket ps, int sw, p_timeout tm) {
+ /*-------------------------------------------------------------------------*\
+ * Select with int timeout in ms
+ \*-------------------------------------------------------------------------*/
+-int socket_select(t_socket n, fd_set *rfds, fd_set *wfds, fd_set *efds, 
++int socket_select(t_socket n, fd_set *rfds, fd_set *wfds, fd_set *efds,
+         p_timeout tm) {
+-    struct timeval tv; 
++    struct timeval tv;
+     double t = timeout_get(tm);
+     tv.tv_sec = (int) t;
+     tv.tv_usec = (int) ((t - tv.tv_sec) * 1.0e6);
+@@ -96,7 +97,7 @@ void socket_destroy(p_socket ps) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* 
++*
+ \*-------------------------------------------------------------------------*/
+ void socket_shutdown(p_socket ps, int how) {
+     socket_setblocking(ps);
+@@ -134,10 +135,10 @@ int socket_connect(p_socket ps, SA *addr, socklen_t len, p_timeout tm) {
+         /* give windows time to set the error (yes, disgusting) */
+         Sleep(10);
+         /* find out why we failed */
+-        getsockopt(*ps, SOL_SOCKET, SO_ERROR, (char *)&err, &len); 
++        getsockopt(*ps, SOL_SOCKET, SO_ERROR, (char *)&err, &len);
+         /* we KNOW there was an error. if 'why' is 0, we will return
+         * "unknown error", but it's not really our fault */
+-        return err > 0? err: IO_UNKNOWN; 
++        return err > 0? err: IO_UNKNOWN;
+     } else return err;
+ 
+ }
+@@ -154,7 +155,7 @@ int socket_bind(p_socket ps, SA *addr, socklen_t len) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* 
++*
+ \*-------------------------------------------------------------------------*/
+ int socket_listen(p_socket ps, int backlog) {
+     int err = IO_DONE;
+@@ -167,7 +168,7 @@ int socket_listen(p_socket ps, int backlog) {
+ /*-------------------------------------------------------------------------*\
+ * Accept with timeout
+ \*-------------------------------------------------------------------------*/
+-int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_t *len, 
++int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_t *len,
+         p_timeout tm) {
+     if (*ps == SOCKET_INVALID) return IO_CLOSED;
+     for ( ;; ) {
+@@ -175,21 +176,21 @@ int socket_accept(p_socket ps, p_socket pa, SA *addr, socklen_t *len,
+         /* try to get client socket */
+         if ((*pa = accept(*ps, addr, len)) != SOCKET_INVALID) return IO_DONE;
+         /* find out why we failed */
+-        err = WSAGetLastError(); 
++        err = WSAGetLastError();
+         /* if we failed because there was no connectoin, keep trying */
+         if (err != WSAEWOULDBLOCK && err != WSAECONNABORTED) return err;
+         /* call select to avoid busy wait */
+         if ((err = socket_waitfd(ps, WAITFD_R, tm)) != IO_DONE) return err;
+-    } 
++    }
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+ * Send with timeout
+-* On windows, if you try to send 10MB, the OS will buffer EVERYTHING 
+-* this can take an awful lot of time and we will end up blocked. 
++* On windows, if you try to send 10MB, the OS will buffer EVERYTHING
++* this can take an awful lot of time and we will end up blocked.
+ * Therefore, whoever calls this function should not pass a huge buffer.
+ \*-------------------------------------------------------------------------*/
+-int socket_send(p_socket ps, const char *data, size_t count, 
++int socket_send(p_socket ps, const char *data, size_t count,
+         size_t *sent, p_timeout tm)
+ {
+     int err;
+@@ -206,18 +207,18 @@ int socket_send(p_socket ps, const char *data, size_t count,
+             return IO_DONE;
+         }
+         /* deal with failure */
+-        err = WSAGetLastError(); 
++        err = WSAGetLastError();
+         /* we can only proceed if there was no serious error */
+         if (err != WSAEWOULDBLOCK) return err;
+         /* avoid busy wait */
+         if ((err = socket_waitfd(ps, WAITFD_W, tm)) != IO_DONE) return err;
+-    } 
++    }
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+ * Sendto with timeout
+ \*-------------------------------------------------------------------------*/
+-int socket_sendto(p_socket ps, const char *data, size_t count, size_t *sent, 
++int socket_sendto(p_socket ps, const char *data, size_t count, size_t *sent,
+         SA *addr, socklen_t len, p_timeout tm)
+ {
+     int err;
+@@ -229,17 +230,17 @@ int socket_sendto(p_socket ps, const char *data, size_t count, size_t *sent,
+             *sent = put;
+             return IO_DONE;
+         }
+-        err = WSAGetLastError(); 
++        err = WSAGetLastError();
+         if (err != WSAEWOULDBLOCK) return err;
+         if ((err = socket_waitfd(ps, WAITFD_W, tm)) != IO_DONE) return err;
+-    } 
++    }
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+ * Receive with timeout
+ \*-------------------------------------------------------------------------*/
+-int socket_recv(p_socket ps, char *data, size_t count, size_t *got, 
+-        p_timeout tm) 
++int socket_recv(p_socket ps, char *data, size_t count, size_t *got,
++        p_timeout tm)
+ {
+     int err, prev = IO_DONE;
+     *got = 0;
+@@ -252,9 +253,9 @@ int socket_recv(p_socket ps, char *data, size_t count, size_t *got,
+         }
+         if (taken == 0) return IO_CLOSED;
+         err = WSAGetLastError();
+-        /* On UDP, a connreset simply means the previous send failed. 
+-         * So we try again. 
+-         * On TCP, it means our socket is now useless, so the error passes. 
++        /* On UDP, a connreset simply means the previous send failed.
++         * So we try again.
++         * On TCP, it means our socket is now useless, so the error passes.
+          * (We will loop again, exiting because the same error will happen) */
+         if (err != WSAEWOULDBLOCK) {
+             if (err != WSAECONNRESET || prev == WSAECONNRESET) return err;
+@@ -267,8 +268,8 @@ int socket_recv(p_socket ps, char *data, size_t count, size_t *got,
+ /*-------------------------------------------------------------------------*\
+ * Recvfrom with timeout
+ \*-------------------------------------------------------------------------*/
+-int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got, 
+-        SA *addr, socklen_t *len, p_timeout tm) 
++int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got,
++        SA *addr, socklen_t *len, p_timeout tm)
+ {
+     int err, prev = IO_DONE;
+     *got = 0;
+@@ -281,8 +282,8 @@ int socket_recvfrom(p_socket ps, char *data, size_t count, size_t *got,
+         }
+         if (taken == 0) return IO_CLOSED;
+         err = WSAGetLastError();
+-        /* On UDP, a connreset simply means the previous send failed. 
+-         * So we try again. 
++        /* On UDP, a connreset simply means the previous send failed.
++         * So we try again.
+          * On TCP, it means our socket is now useless, so the error passes.
+          * (We will loop again, exiting because the same error will happen) */
+         if (err != WSAEWOULDBLOCK) {
+@@ -310,7 +311,7 @@ void socket_setnonblocking(p_socket ps) {
+ }
+ 
+ /*-------------------------------------------------------------------------*\
+-* DNS helpers 
++* DNS helpers
+ \*-------------------------------------------------------------------------*/
+ int socket_gethostbyaddr(const char *addr, socklen_t len, struct hostent **hp) {
+     *hp = gethostbyaddr(addr, len, AF_INET);
+@@ -330,21 +331,21 @@ int socket_gethostbyname(const char *addr, struct hostent **hp) {
+ const char *socket_hoststrerror(int err) {
+     if (err <= 0) return io_strerror(err);
+     switch (err) {
+-        case WSAHOST_NOT_FOUND: return "host not found";
+-        default: return wstrerror(err); 
++        case WSAHOST_NOT_FOUND: return PIE_HOST_NOT_FOUND;
++        default: return wstrerror(err);
+     }
+ }
+ 
+ const char *socket_strerror(int err) {
+     if (err <= 0) return io_strerror(err);
+     switch (err) {
+-        case WSAEADDRINUSE: return "address already in use";
+-        case WSAECONNREFUSED: return "connection refused";
+-        case WSAEISCONN: return "already connected";
+-        case WSAEACCES: return "permission denied";
+-        case WSAECONNABORTED: return "closed";
+-        case WSAECONNRESET: return "closed";
+-        case WSAETIMEDOUT: return "timeout";
++        case WSAEADDRINUSE: return PIE_ADDRINUSE;
++        case WSAECONNREFUSED : return PIE_CONNREFUSED;
++        case WSAEISCONN: return PIE_ISCONN;
++        case WSAEACCES: return PIE_ACCESS;
++        case WSAECONNABORTED: return PIE_CONNABORTED;
++        case WSAECONNRESET: return PIE_CONNRESET;
++        case WSAETIMEDOUT: return PIE_TIMEDOUT;
+         default: return wstrerror(err);
+     }
+ }
+@@ -357,7 +358,7 @@ const char *socket_ioerror(p_socket ps, int err) {
+ static const char *wstrerror(int err) {
+     switch (err) {
+         case WSAEINTR: return "Interrupted function call";
+-        case WSAEACCES: return "Permission denied";
++        case WSAEACCES: return PIE_ACCESS; // "Permission denied";
+         case WSAEFAULT: return "Bad address";
+         case WSAEINVAL: return "Invalid argument";
+         case WSAEMFILE: return "Too many open files";
+@@ -370,63 +371,61 @@ static const char *wstrerror(int err) {
+         case WSAEPROTOTYPE: return "Protocol wrong type for socket";
+         case WSAENOPROTOOPT: return "Bad protocol option";
+         case WSAEPROTONOSUPPORT: return "Protocol not supported";
+-        case WSAESOCKTNOSUPPORT: return "Socket type not supported";
++        case WSAESOCKTNOSUPPORT: return PIE_SOCKTYPE; // "Socket type not supported";
+         case WSAEOPNOTSUPP: return "Operation not supported";
+         case WSAEPFNOSUPPORT: return "Protocol family not supported";
+-        case WSAEAFNOSUPPORT: 
+-            return "Address family not supported by protocol family"; 
+-        case WSAEADDRINUSE: return "Address already in use";
++        case WSAEAFNOSUPPORT: return PIE_FAMILY; // "Address family not supported by protocol family";
++        case WSAEADDRINUSE: return PIE_ADDRINUSE; // "Address already in use";
+         case WSAEADDRNOTAVAIL: return "Cannot assign requested address";
+         case WSAENETDOWN: return "Network is down";
+         case WSAENETUNREACH: return "Network is unreachable";
+         case WSAENETRESET: return "Network dropped connection on reset";
+         case WSAECONNABORTED: return "Software caused connection abort";
+-        case WSAECONNRESET: return "Connection reset by peer";
++        case WSAECONNRESET: return PIE_CONNRESET; // "Connection reset by peer";
+         case WSAENOBUFS: return "No buffer space available";
+-        case WSAEISCONN: return "Socket is already connected";
++        case WSAEISCONN: return PIE_ISCONN; // "Socket is already connected";
+         case WSAENOTCONN: return "Socket is not connected";
+         case WSAESHUTDOWN: return "Cannot send after socket shutdown";
+-        case WSAETIMEDOUT: return "Connection timed out";
+-        case WSAECONNREFUSED: return "Connection refused";
++        case WSAETIMEDOUT: return PIE_TIMEDOUT; // "Connection timed out";
++        case WSAECONNREFUSED: return PIE_CONNREFUSED; // "Connection refused";
+         case WSAEHOSTDOWN: return "Host is down";
+         case WSAEHOSTUNREACH: return "No route to host";
+         case WSAEPROCLIM: return "Too many processes";
+         case WSASYSNOTREADY: return "Network subsystem is unavailable";
+         case WSAVERNOTSUPPORTED: return "Winsock.dll version out of range";
+-        case WSANOTINITIALISED: 
++        case WSANOTINITIALISED:
+             return "Successful WSAStartup not yet performed";
+         case WSAEDISCON: return "Graceful shutdown in progress";
+-        case WSAHOST_NOT_FOUND: return "Host not found";
++        case WSAHOST_NOT_FOUND: return PIE_HOST_NOT_FOUND; // "Host not found";
+         case WSATRY_AGAIN: return "Nonauthoritative host not found";
+-        case WSANO_RECOVERY: return "Nonrecoverable name lookup error"; 
++        case WSANO_RECOVERY: return PIE_FAIL; // "Nonrecoverable name lookup error";
+         case WSANO_DATA: return "Valid name, no data record of requested type";
+         default: return "Unknown error";
+     }
+ }
+ 
+ const char *socket_gaistrerror(int err) {
+-    if (err == 0) return NULL; 
++    if (err == 0) return NULL;
+     switch (err) {
+-        case EAI_AGAIN: return "temporary failure in name resolution";
+-        case EAI_BADFLAGS: return "invalid value for ai_flags";
++        case EAI_AGAIN: return PIE_AGAIN;
++        case EAI_BADFLAGS: return PIE_BADFLAGS;
+ #ifdef EAI_BADHINTS
+-        case EAI_BADHINTS: return "invalid value for hints";
++        case EAI_BADHINTS: return PIE_BADHINTS;
+ #endif
+-        case EAI_FAIL: return "non-recoverable failure in name resolution";
+-        case EAI_FAMILY: return "ai_family not supported";
+-        case EAI_MEMORY: return "memory allocation failure";
+-        case EAI_NONAME: 
+-            return "host or service not provided, or not known";
++        case EAI_FAIL: return PIE_FAIL;
++        case EAI_FAMILY: return PIE_FAMILY;
++        case EAI_MEMORY: return PIE_MEMORY;
++        case EAI_NONAME: return PIE_NONAME;
+ #ifdef EAI_OVERFLOW
+-        case EAI_OVERFLOW: return "argument buffer overflow";
++        case EAI_OVERFLOW: return PIE_OVERFLOW;
+ #endif
+ #ifdef EAI_PROTOCOL
+-        case EAI_PROTOCOL: return "resolved protocol is unknown";
++        case EAI_PROTOCOL: return PIE_PROTOCOL;
+ #endif
+-        case EAI_SERVICE: return "service not supported for socket type";
+-        case EAI_SOCKTYPE: return "ai_socktype not supported";
++        case EAI_SERVICE: return PIE_SERVICE;
++        case EAI_SOCKTYPE: return PIE_SOCKTYPE;
+ #ifdef EAI_SYSTEM
+-        case EAI_SYSTEM: return strerror(errno); 
++        case EAI_SYSTEM: return strerror(errno);
+ #endif
+         default: return gai_strerror(err);
+     }
+diff --git a/test/auth/.htaccess b/test/auth/.htaccess
+new file mode 100644
+index 0000000..bb2794a
+--- /dev/null
++++ b/test/auth/.htaccess
+@@ -0,0 +1,4 @@
++AuthName "test-auth"
++    AuthType Basic
++    AuthUserFile /Users/diego/impa/luasocket/test/auth/.htpasswd
++    Require valid-user
+diff --git a/test/auth/.htpasswd b/test/auth/.htpasswd
+index fd9002b..cfb2603 100644
+--- a/test/auth/.htpasswd
++++ b/test/auth/.htpasswd
+@@ -1 +1 @@
+-luasocket:l8n2npozPB.sQ
++luasocket:$apr1$47u2O.Me$.m/5BWAtt7GVoxsouIPBR1
+diff --git a/test/excepttest.lua b/test/excepttest.lua
+index ce9f197..80c9cb8 100644
+--- a/test/excepttest.lua
++++ b/test/excepttest.lua
+@@ -1,6 +1,30 @@
+ local socket = require("socket")
+-try = socket.newtry(function()
+-    print("finalized!!!")
++
++local finalizer_called
++
++local func = socket.protect(function(err, ...)
++    local try = socket.newtry(function()
++        finalizer_called = true
++    end)
++
++    if err then
++        return error(err, 0)
++    else
++        return try(...)
++    end
+ end)
+-try = socket.protect(try)
+-print(try(nil, "it works"))
++
++local ret1, ret2, ret3 = func(false, 1, 2, 3)
++assert(not finalizer_called, "unexpected finalizer call")
++assert(ret1 == 1 and ret2 == 2 and ret3 == 3, "incorrect return values")
++
++ret1, ret2, ret3 = func(false, false, "error message")
++assert(finalizer_called, "finalizer not called")
++assert(ret1 == nil and ret2 == "error message" and ret3 == nil, "incorrect return values")
++
++local err = {key = "value"}
++ret1, ret2 = pcall(func, err)
++assert(not ret1, "error not rethrown")
++assert(ret2 == err, "incorrect error rethrown")
++
++print("OK")
+diff --git a/test/httptest.lua b/test/httptest.lua
+index d5fbb37..63ff921 100644
+--- a/test/httptest.lua
++++ b/test/httptest.lua
+@@ -1,4 +1,4 @@
+--- needs Alias from /home/c/diego/tec/luasocket/test to 
++-- needs Alias from /home/c/diego/tec/luasocket/test to
+ -- "/luasocket-test" and "/luasocket-test/"
+ -- needs ScriptAlias from /home/c/diego/tec/luasocket/test/cgi
+ -- to "/luasocket-test-cgi" and "/luasocket-test-cgi/"
+@@ -36,22 +36,22 @@ index = readfile(index_file)
+ local check_result = function(response, expect, ignore)
+     for i,v in pairs(response) do
+         if not ignore[i] then
+-            if v ~= expect[i] then 
++            if v ~= expect[i] then
+                 local f = io.open("err", "w")
+                 f:write(tostring(v), "\n\n versus\n\n", tostring(expect[i]))
+                 f:close()
+-                fail(i .. " differs!") 
++                fail(i .. " differs!")
+             end
+         end
+     end
+     for i,v in pairs(expect) do
+         if not ignore[i] then
+-            if v ~= response[i] then 
++            if v ~= response[i] then
+                 local f = io.open("err", "w")
+                 f:write(tostring(response[i]), "\n\n versus\n\n", tostring(v))
+                 v = string.sub(type(v) == "string" and v or "", 1, 70)
+                 f:close()
+-                fail(i .. " differs!") 
++                fail(i .. " differs!")
+             end
+         end
+     end
+@@ -61,10 +61,10 @@ end
+ local check_request = function(request, expect, ignore)
+     local t
+     if not request.sink then request.sink, t = ltn12.sink.table() end
+-    request.source = request.source or 
++    request.source = request.source or
+         (request.body and ltn12.source.string(request.body))
+     local response = {}
+-    response.code, response.headers, response.status = 
++    response.code, response.headers, response.status =
+         socket.skip(1, http.request(request))
+     if t and #t > 0 then response.body = table.concat(t) end
+     check_result(response, expect, ignore)
+@@ -82,7 +82,7 @@ else fail(back.query) end
+ ------------------------------------------------------------------------
+ io.write("testing query string correctness: ")
+ forth = "this+is+the+query+string"
+-back = http.request("http://" .. host .. cgiprefix .. 
++back = http.request("http://" .. host .. cgiprefix ..
+     "/query-string?" .. forth)
+ if similar(back, forth) then print("ok")
+ else fail("failed!") end
+@@ -120,10 +120,10 @@ check_request(request, expect, ignore)
+ ------------------------------------------------------------------------
+ io.write("testing invalid url: ")
+ local r, e = http.request{url = host .. prefix}
+-assert(r == nil and e == "invalid host ''") 
++assert(r == nil and e == "invalid host ''")
+ r, re = http.request(host .. prefix)
+-assert(r == nil and e == re, tostring(r) ..", " .. tostring(re) .. 
+-    " vs " .. tostring(e)) 
++assert(r == nil and e == re, tostring(r) ..", " .. tostring(re) ..
++    " vs " .. tostring(e))
+ print("ok")
+ 
+ io.write("testing invalid empty port: ")
+@@ -212,7 +212,7 @@ os.remove(index_file .. "-back")
+ io.write("testing ltn12.(sink|source).chain and mime.(encode|decode): ")
+ 
+ local function b64length(len)
+-    local a = math.ceil(len/3)*4 
++    local a = math.ceil(len/3)*4
+     local l = math.ceil(a/76)
+     return a + l*2
+ end
+@@ -313,7 +313,7 @@ ignore = {
+     headers = 1
+ }
+ check_request(request, expect, ignore)
+-    
++
+ ------------------------------------------------------------------------
+ io.write("testing document not found: ")
+ request = {
+@@ -429,9 +429,9 @@ print("ok")
+ io.write("testing host not found: ")
+ local c, e = socket.connect("example.invalid", 80)
+ local r, re = http.request{url = "http://example.invalid/does/not/exist"}
+-assert(r == nil and e == re, tostring(r) .. " " .. tostring(re)) 
++assert(r == nil and e == re, tostring(r) .. " " .. tostring(re))
+ r, re = http.request("http://example.invalid/does/not/exist")
+-assert(r == nil and e == re) 
++assert(r == nil and e == re)
+ print("ok")
+ 
+ ------------------------------------------------------------------------
+diff --git a/test/ltn12test.lua b/test/ltn12test.lua
+index 74a45e8..e3f85fb 100644
+--- a/test/ltn12test.lua
++++ b/test/ltn12test.lua
+@@ -192,6 +192,21 @@ assert(filter(nil, 1), "filter not empty")
+ print("ok")
+ 
+ --------------------------------
++io.write("testing source.chain (with several filters): ")
++local function double(x) -- filter turning "ABC" into "AABBCC"
++    if not x then return end
++    local b={}
++    for k in x:gmatch'.' do table.insert(b, k..k) end
++    return table.concat(b)
++end
++source = ltn12.source.string(s)
++source = ltn12.source.chain(source, double, double, double)
++sink, t = ltn12.sink.table()
++assert(ltn12.pump.all(source, sink), "returned error")
++assert(table.concat(t) == double(double(double(s))), "mismatch")
++print("ok")
++
++--------------------------------
+ io.write("testing source.chain (with split) and sink.chain (with merge): ")
+ source = ltn12.source.string(s)
+ filter = split(5)
+@@ -206,6 +221,15 @@ assert(filter2(nil, 1), "filter2 not empty")
+ print("ok")
+ 
+ --------------------------------
++io.write("testing sink.chain (with several filters): ")
++source = ltn12.source.string(s)
++sink, t = ltn12.sink.table()
++sink = ltn12.sink.chain(double, double, double, sink)
++assert(ltn12.pump.all(source, sink), "returned error")
++assert(table.concat(t) == double(double(double(s))), "mismatch")
++print("ok")
++
++--------------------------------
+ io.write("testing filter.chain (and sink.chain, with split, merge): ")
+ source = ltn12.source.string(s)
+ filter = split(5)
+@@ -272,3 +296,4 @@ assert(filter3(nil, 1), "filter3 not empty")
+ assert(filter4(nil, 1), "filter4 not empty")
+ assert(filter5(nil, 1), "filter5 not empty")
+ print("ok")
++
+diff --git a/test/testclnt.lua b/test/testclnt.lua
+index 315783b..170e187 100644
+--- a/test/testclnt.lua
++++ b/test/testclnt.lua
+@@ -8,7 +8,7 @@ function printf(...)
+ end
+ 
+ function pass(...)
+-    printf(...) 
++    printf(...)
+     io.stderr:write("\n")
+ end
+ 
+@@ -45,30 +45,30 @@ function check_timeout(tm, sl, elapsed, err, opp, mode, alldone)
+             if not err then warn("must be buffered")
+             elseif err == "timeout" then pass("proper timeout")
+             else fail("unexpected error '%s'", err) end
+-        else 
+-            if err ~= "timeout" then fail("should have timed out") 
++        else
++            if err ~= "timeout" then fail("should have timed out")
+             else pass("proper timeout") end
+         end
+     else
+         if mode == "total" then
+-            if elapsed > tm then 
++            if elapsed > tm then
+                 if err ~= "timeout" then fail("should have timed out")
+                 else pass("proper timeout") end
+             elseif elapsed < tm then
+-                if err then fail(err) 
++                if err then fail(err)
+                 else pass("ok") end
+-            else 
+-                if alldone then 
+-                    if err then fail("unexpected error '%s'", err) 
++            else
++                if alldone then
++                    if err then fail("unexpected error '%s'", err)
+                     else pass("ok") end
+                 else
+-                    if err ~= "timeout" then fail(err) 
++                    if err ~= "timeout" then fail(err)
+                     else pass("proper timeoutk") end
+                 end
+             end
+-        else 
+-            if err then fail(err) 
+-            else pass("ok") end 
++        else
++            if err then fail(err)
++            else pass("ok") end
+         end
+     end
+ end
+@@ -104,8 +104,8 @@ control:setoption("tcp-nodelay", true)
+ ------------------------------------------------------------------------
+ function test_methods(sock, methods)
+     for _, v in pairs(methods) do
+-        if type(sock[v]) ~= "function" then 
+-            fail(sock.class .. " method '" .. v .. "' not registered") 
++        if type(sock[v]) ~= "function" then
++            fail(sock.class .. " method '" .. v .. "' not registered")
+         end
+     end
+     pass(sock.class .. " methods are ok")
+@@ -121,7 +121,7 @@ function test_mixed(len)
+     local p3 = "raw " .. string.rep("z", inter) .. "bytes"
+     local p4 = "end" .. string.rep("w", inter) .. "bytes"
+     local bp1, bp2, bp3, bp4
+-remote (string.format("str = data:receive(%d)", 
++remote (string.format("str = data:receive(%d)",
+             string.len(p1)+string.len(p2)+string.len(p3)+string.len(p4)))
+     sent, err = data:send(p1..p2..p3..p4)
+     if err then fail(err) end
+@@ -166,7 +166,7 @@ function test_rawline(len)
+     io.stderr:write("length " .. len .. ": ")
+     local str, str10, back, err
+     str = string.rep(string.char(47), math.mod(len, 10))
+-    str10 = string.rep(string.char(120,21,77,4,5,0,7,36,44,100), 
++    str10 = string.rep(string.char(120,21,77,4,5,0,7,36,44,100),
+             math.floor(len/10))
+     str = str .. str10
+ remote "str = data:receive()"
+@@ -216,7 +216,7 @@ function test_totaltimeoutreceive(len, tm, sl)
+     data:settimeout(tm, "total")
+ local t = socket.gettime()
+     str, err, partial, elapsed = data:receive(2*len)
+-    check_timeout(tm, sl, elapsed, err, "receive", "total", 
++    check_timeout(tm, sl, elapsed, err, "receive", "total",
+         string.len(str or partial) == 2*len)
+ end
+ 
+@@ -236,7 +236,7 @@ function test_totaltimeoutsend(len, tm, sl)
+     data:settimeout(tm, "total")
+     str = string.rep("a", 2*len)
+     total, err, partial, elapsed = data:send(str)
+-    check_timeout(tm, sl, elapsed, err, "send", "total", 
++    check_timeout(tm, sl, elapsed, err, "send", "total",
+         total == 2*len)
+ end
+ 
+@@ -256,7 +256,7 @@ function test_blockingtimeoutreceive(len, tm, sl)
+     ]], 2*tm, len, sl, sl))
+     data:settimeout(tm)
+     str, err, partial, elapsed = data:receive(2*len)
+-    check_timeout(tm, sl, elapsed, err, "receive", "blocking", 
++    check_timeout(tm, sl, elapsed, err, "receive", "blocking",
+         string.len(str or partial) == 2*len)
+ end
+ 
+@@ -290,10 +290,10 @@ function empty_connect()
+         data = server:accept()
+     ]]
+     data, err = socket.connect("", port)
+-    if not data then 
++    if not data then
+         pass("ok")
+         data = socket.connect(host, port)
+-    else 
++    else
+         pass("gethostbyname returns localhost on empty string...")
+     end
+ end
+@@ -304,15 +304,20 @@ function isclosed(c)
+ end
+ 
+ function active_close()
+-    reconnect()
+-    if isclosed(data) then fail("should not be closed") end
+-    data:close()
+-    if not isclosed(data) then fail("should be closed") end
+-    data = nil
+-    local udp = socket.udp()
++    local tcp = socket.tcp4()
++    if isclosed(tcp) then fail("should not be closed") end
++    tcp:close()
++    if not isclosed(tcp) then fail("should be closed") end
++    tcp = socket.tcp()
++    if not isclosed(tcp) then fail("should be closed") end
++    tcp = nil
++    local udp = socket.udp4()
+     if isclosed(udp) then fail("should not be closed") end
+     udp:close()
+     if not isclosed(udp) then fail("should be closed") end
++    udp = socket.udp()
++    if not isclosed(udp) then fail("should be closed") end
++    udp = nil
+     pass("ok")
+ end
+ 
+@@ -327,7 +332,7 @@ function test_closed()
+         data:close()
+         data = nil
+     ]], str))
+-    -- try to get a line 
++    -- try to get a line
+     back, err, partial = data:receive()
+     if not err then fail("should have gotten 'closed'.")
+     elseif err ~= "closed" then fail("got '"..err.."' instead of 'closed'.")
+@@ -340,25 +345,25 @@ function test_closed()
+         data = nil
+     ]]
+     total, err, partial = data:send(string.rep("ugauga", 100000))
+-    if not err then 
++    if not err then
+         pass("failed: output buffer is at least %d bytes long!", total)
+-    elseif err ~= "closed" then 
++    elseif err ~= "closed" then
+         fail("got '"..err.."' instead of 'closed'.")
+-    else 
+-        pass("graceful 'closed' received after %d bytes were sent", partial) 
++    else
++        pass("graceful 'closed' received after %d bytes were sent", partial)
+     end
+ end
+ 
+ ------------------------------------------------------------------------
+ function test_selectbugs()
+     local r, s, e = socket.select(nil, nil, 0.1)
+-    assert(type(r) == "table" and type(s) == "table" and 
++    assert(type(r) == "table" and type(s) == "table" and
+         (e == "timeout" or e == "error"))
+     pass("both nil: ok")
+     local udp = socket.udp()
+     udp:close()
+     r, s, e = socket.select({ udp }, { udp }, 0.1)
+-    assert(type(r) == "table" and type(s) == "table" and 
++    assert(type(r) == "table" and type(s) == "table" and
+         (e == "timeout" or e == "error"))
+     pass("closed sockets: ok")
+     e = pcall(socket.select, "wrong", 1, 0.1)
+@@ -368,7 +373,7 @@ function test_selectbugs()
+     pass("invalid input: ok")
+     local toomany = {}
+     for i = 1, socket._SETSIZE+1 do
+-        toomany[#toomany+1] = socket.udp()
++        toomany[#toomany+1] = socket.udp4()
+     end
+     if #toomany > socket._SETSIZE then
+         local e = pcall(socket.select, toomany, nil, 0.1)
+@@ -389,7 +394,7 @@ function accept_timeout()
+     local t = socket.gettime()
+     s:settimeout(1)
+     local c, e = s:accept()
+-    assert(not c, "should not accept") 
++    assert(not c, "should not accept")
+     assert(e == "timeout", string.format("wrong error message (%s)", e))
+     t = socket.gettime() - t
+     assert(t < 2, string.format("took to long to give up (%gs)", t))
+@@ -407,9 +412,9 @@ function connect_timeout()
+     local t = socket.gettime()
+     local r, e = c:connect("10.0.0.1", 81)
+     assert(not r, "should not connect")
+-    assert(socket.gettime() - t < 2, "took too long to give up.") 
++    assert(socket.gettime() - t < 2, "took too long to give up.")
+     c:close()
+-    pass("ok") 
++    pass("ok")
+ end
+ 
+ ------------------------------------------------------------------------
+@@ -447,16 +452,14 @@ end
+ 
+ ------------------------------------------------------------------------
+ function rebind_test()
+-    --local c ,c1 = socket.bind("localhost", 0)
+    local c ,c1 = socket.bind("127.0.0.1", 0)
+     if not c then pass ("failed to bind! " .. tostring(c) .. ' ' .. tostring(c1))  return end
+ 	assert(c,c1)
+- 
+     local i, p = c:getsockname()
+     local s, e = socket.tcp()
+     assert(s, e)
+     s:setoption("reuseaddr", false)
+-    r, e = s:bind("localhost", p)
++    r, e = s:bind(i, p)
+     assert(not r, "managed to rebind!")
+     assert(e)
+     pass("ok")
+@@ -476,9 +479,9 @@ function getstats_test()
+         data:receive(c)
+         t = t + c
+         local r, s, a = data:getstats()
+-        assert(r == t, "received count failed" .. tostring(r) 
++        assert(r == t, "received count failed" .. tostring(r)
+             .. "/" .. tostring(t))
+-        assert(s == t, "sent count failed" .. tostring(s) 
++        assert(s == t, "sent count failed" .. tostring(s)
+             .. "/" .. tostring(t))
+     end
+     pass("ok")
+@@ -486,7 +489,7 @@ end
+ 
+ 
+ ------------------------------------------------------------------------
+-function test_nonblocking(size) 
++function test_nonblocking(size)
+     reconnect()
+     printf("testing "  .. 2*size .. " bytes: ")
+ remote(string.format([[
+@@ -545,7 +548,7 @@ function test_readafterclose()
+         data:close()
+         data = nil
+     ]]))
+-    data:close() 
++    data:close()
+     back, err, partial = data:receive("*a")
+     assert(back == nil and err == "closed", "should have returned 'closed'")
+     pass("ok")
+@@ -555,7 +558,7 @@ function test_readafterclose()
+         data:close()
+         data = nil
+     ]]))
+-    data:close() 
++    data:close()
+     back, err, partial = data:receive()
+     assert(back == nil and err == "closed", "should have returned 'closed'")
+     pass("ok")
+@@ -565,7 +568,7 @@ function test_readafterclose()
+         data:close()
+         data = nil
+     ]]))
+-    data:close() 
++    data:close()
+     back, err, partial = data:receive(1)
+     assert(back == nil and err == "closed", "should have returned 'closed'")
+     pass("ok")
+@@ -575,7 +578,7 @@ function test_readafterclose()
+         data:close()
+         data = nil
+     ]]))
+-    data:close() 
++    data:close()
+     back, err, partial = data:receive(0)
+     assert(back == nil and err == "closed", "should have returned 'closed'")
+     pass("ok")
+@@ -590,10 +593,10 @@ function test_writeafterclose()
+         data = nil
+     ]]))
+     local sent, err, errsent
+-    while not err do 
++    while not err do
+         sent, err, errsent, time = data:send(str)
+     end
+-    assert(err == "closed", "should have returned 'closed'")
++    assert(err == "closed", "got " .. err .. " instead of 'closed'")
+     pass("ok")
+ end
+ 
+@@ -648,25 +651,24 @@ else io.stderr:write("Warning! IPv6 does not support!\n") end
+ end
+ 
+ local udp_methods = {
+-    "close", 
++    "close",
+     "dirty",
+     "getfamily",
+     "getfd",
+     "getoption",
+     "getpeername",
+     "getsockname",
+-    "receive", 
+-    "receivefrom", 
+-    "send", 
+-    "sendto", 
+-    "setfd", 
++    "receive",
++    "receivefrom",
++    "send",
++    "sendto",
++    "setfd",
+     "setoption",
+     "setpeername",
+     "setsockname",
+     "settimeout"
+ }
+ 
+-
+ ------------------------------------------------------------------------
+ test_methods(socket.udp(), udp_methods)
+ do local sock = socket.tcp6()
+@@ -674,6 +676,9 @@ if sock then test_methods(socket.udp6(), udp_methods)
+ else io.stderr:write("Warning! IPv6 does not support!\n") end
+ end
+ 
++test("closed connection detection: ")
++test_closed()
++
+ test("partial receive")
+ test_partialrecv()
+ 
+@@ -697,9 +702,6 @@ rebind_test()
+ test("active close: ")
+ active_close()
+ 
+-test("closed connection detection: ")
+-test_closed()
+-
+ test("accept function: ")
+ accept_timeout()
+ accept_errors()
+diff --git a/test/testsrvr.lua b/test/testsrvr.lua
+index 72b93ab..1eb2d5b 100644
+--- a/test/testsrvr.lua
++++ b/test/testsrvr.lua
+@@ -6,7 +6,7 @@ ack = "\n";
+ while 1 do
+     print("server: waiting for client connection...");
+     control = assert(server:accept());
+-    while 1 do 
++    while 1 do
+         command, emsg = control:receive();
+         if emsg == "closed" then
+             control:close()
+diff --git a/test/udpconnectclnt.lua b/test/udpconnectclnt.lua
+index effe13a..ad6ab6a 100644
+--- a/test/udpconnectclnt.lua
++++ b/test/udpconnectclnt.lua
+@@ -1,7 +1,7 @@
+ local socket = require"socket"
+ local udp = socket.udp
+ local localhost = "127.0.0.1"
+-local port = arg[1]
++local port = assert(arg[1], "missing port argument")
+ 
+ se = udp(); se:setoption("reuseaddr", true)
+ se:setsockname(localhost, 5062)
+diff --git a/win32.cmd b/win32.cmd
+index 48522f0..3045721 100644
+--- a/win32.cmd
++++ b/win32.cmd
+@@ -1,12 +1 @@
+-make PLAT=win32 LUAV=5.2 LUAINC_win32='c:\cygwin\home\diego\build\include' LUALIB_win32='c:\cygwin\home\diego\build\bin\release'
+-
+-#!/bin/sh
+-for p in Release Debug x64/Release x64/Debug; do
+-    for el in mime socket; do
+-        for e in dll lib; do
+-            cp $p/$el/core.$e ../bin/$p/$el/
+-        done;
+-    done;
+-    cp src/ltn12.lua src/socket.lua src/mime.lua ../bin/$p/
+-    cp src/http.lua src/url.lua src/tp.lua src/ftp.lua src/headers.lua src/smtp.lua ../bin/$p/socket/
+-done;
++make LUAPREFIX_win32='c:\cygwin\home\diego\vc12' LUAV=5.1 PLAT=win32 LUALIBNAME_win32=lualib.lib PLATFORM_win32=Debug install-both
diff --git a/user/lua-socket/lua-cflags.patch b/user/lua-socket/lua-cflags.patch
new file mode 100644
index 000000000..c1da89644
--- /dev/null
+++ b/user/lua-socket/lua-cflags.patch
@@ -0,0 +1,22 @@
+diff --git a/src/makefile b/src/makefile
+index adf687f..c2abddc 100644
+--- a/src/makefile
++++ b/src/makefile
+@@ -160,6 +160,8 @@ SOCKET_macosx=usocket.o
+ #------
+ # Compiler and linker settings
+ # for Linux
++LUAPC=lua
++LUA_CFLAGS=$(shell pkg-config --cflags $(LUAPC))
+ SO_linux=so
+ O_linux=o
+ CC_linux=gcc
+@@ -167,7 +169,7 @@ DEF_linux=-DLUASOCKET_$(DEBUG) \
+ 	-DLUASOCKET_API='__attribute__((visibility("default")))' \
+ 	-DUNIX_API='__attribute__((visibility("default")))' \
+ 	-DMIME_API='__attribute__((visibility("default")))'
+-CFLAGS_linux= -I$(LUAINC) $(DEF) -Wall -Wshadow -Wextra \
++CFLAGS_linux= $(LUA_CFLAGS) -I$(LUAINC) $(DEF) -Wall -Wshadow -Wextra \
+ 	-Wimplicit -O2 -ggdb3 -fpic -fvisibility=hidden
+ LDFLAGS_linux=-O -shared -fpic -o 
+ LD_linux=gcc
-- 
cgit v1.2.3-60-g2f50