Patches for aports can be sent to this list

3 2

[alpine-aports] [PATCH] main/lua-socket: cleanup and upgrade to latest git

Muh Muhten
Details
Message ID
<1457305237-43494-1-git-send-email-muh.muhten@gmail.com>
Sender timestamp
1457305237
DKIM signature
missing
Download raw message
Patch: +5217 -214
Fast-forward to pick up fixes since last release, remove patches that no longer
apply, and clean up APKBUILD to closer to the current style.

---
Not too sure I got the patchset right here. Fast-forward because it's been a
year since last update and there have been substantial bugfixes since.

Removed patches that no longer apply cleanly; unix.patch was no longer used.
I'm not sure what include-luasocket.patch was for; it compiles cleanly without
it but the change is not reflected upstream--is it necessary?

Can we look into getting lua-cflags upstreamed? It doesn't seem like it should
be too distro-specific, I'm not sure.

A bit of cleanup in the APKBUILD.

 main/lua-socket/APKBUILD                |   40 +-
 main/lua-socket/git.patch               | 5346 ++++++++++++++++++++++++++++++-
 main/lua-socket/include-luasocket.patch |   10 -
 main/lua-socket/lua-cflags.patch        |   10 +-
 main/lua-socket/unix.patch              |   25 -
 5 files changed, 5217 insertions(+), 214 deletions(-)
 delete mode 100644 main/lua-socket/include-luasocket.patch
 delete mode 100644 main/lua-socket/unix.patch

diff --git a/main/lua-socket/APKBUILD b/main/lua-socket/APKBUILD
index d2b1251..86dea01 100644
--- a/main/lua-socket/APKBUILD
+++ b/main/lua-socket/APKBUILD
@@ -3,7 +3,7 @@
 _luaversions="5.1 5.2 5.3"
 pkgname=lua-socket
 _name=luasocket
-pkgver=3.0_rc1_git20150301
+pkgver=3.0_rc1_git20160306
 pkgrel=0
 _ver=${pkgver%_git*}
 _ver=${_ver/_rc/-rc}
@@ -11,8 +11,8 @@ pkgdesc="Networking library for Lua"
 url="http://luaforge.net/projects/luasocket/"
 arch="all"
 license="MIT"
-install=
-depends="lua5.1-socket"
+install=""
+depends=""
 makedepends=""
 subpackages=""
 for _i in $_luaversions; do
@@ -22,21 +22,15 @@ done
 source="luasocket-$_ver.tar.gz::https://github.com/diegonehab/luasocket/archive/v$_ver.tar.gz
 	git.patch
 	lua-cflags.patch
-	include-luasocket.patch
 	"
 
-_sdir="$srcdir/$_name-$_ver"
+# default_prepare assumes $_builddir
+_builddir="$srcdir/$_name-$_ver"
 
 prepare() {
-	cd "$_sdir"
-	for i in $source; do
-		case $i in
-		*.patch) msg $i; patch -p1 -i "$srcdir"/$i || return 1;;
-		esac
-	done
-
+	default_prepare
 	for _i in $_luaversions; do
-		cp -r "$_sdir" "$srcdir"/build-$_i
+		cp -r "$_builddir" "$srcdir"/build-$_i
 		# set lua version
 		sed -i -e "/^LUAV?=/s/=.*/=$_i/" \
 			"$srcdir"/build-$_i/src/makefile || return 1
@@ -44,27 +38,22 @@ prepare() {
 }
 
 build() {
-	cd "$_builddir"
 	for _i in $_luaversions; do
 		make -C "$srcdir"/build-$_i/src all-unix || return 1
 	done
 }
 
 package() {
-	cd "$_builddir"
 	for _i in $_luaversions; do
 		cd "$srcdir"/build-$_i
 		make prefix=/usr DESTDIR="$pkgdir" install-unix || return 1
 	done
-
 }
 
 _split() {
 	local d= _ver=$1
 	pkgdesc="Networking library for Lua $_ver"
 	install_if="lua$_ver $pkgname=$pkgver-r$pkgrel"
-	replaces="$pkgname"
-	depends=
 	for d in usr/lib/lua usr/share/lua; do
 		if [ -d "$pkgdir"/$d/$_ver ]; then
 			mkdir -p "$subpkgdir"/$d
@@ -78,14 +67,11 @@ for _i in $_luaversions; do
 done
 
 md5sums="08bd2f265b244eb4bf5c2c36bf89b759  luasocket-3.0-rc1.tar.gz
-2e14aba126cec984e1824a4da35d45f8  git.patch
-8adb3bb6f4c6f63de8c56412ef623953  lua-cflags.patch
-4bcbbc8d3383db94223155fc7a6d454e  include-luasocket.patch"
+44c07dc3dd311541a50b21aaa40e36d7  git.patch
+d4319e4a20d476ea8d77a3421fca1808  lua-cflags.patch"
 sha256sums="8b67d9b5b545e1b694753dab7bd6cdbc24c290f2b21ba1e14c77b32817ea1249  luasocket-3.0-rc1.tar.gz
-d64d35ba14a8b1381c20273d1390ee7c170b4ff566ad503621cac9f4c129bbb8  git.patch
-e5d38d3b1484b61ab43627efdc302f78c24733aa2d422e6745fe273b1a56d94b  lua-cflags.patch
-42b1a439805efaf33110e01a53798b3e8d044101470808fe9478ca3be0ae5165  include-luasocket.patch"
+414cfe53e4455fc2b416779d5eaa3ade6d97c01fa62dbffb6c9d4d4ad84bdd76  git.patch
+77d77fe688b27ae51bcf9d3ae51d43141ab85d95fd322b3904b55dbc76900418  lua-cflags.patch"
 sha512sums="f6efce259aaacaa11472911471f8a13b118fe009b8953a82c6aa18b9ec829cd1293180904e56935cb130d36d267e3f27c91db2d78e03f7488f3e100571ed0540  luasocket-3.0-rc1.tar.gz
-85a6dc3b8e674200a2928f397fcb7fb9ca0e41870d5628c9c24aabc140d8fa14c12576cfa6e8bef687ab914d378585557b9a2f3bf09173a003d51f7f8e2a0d34  git.patch
-9a155e11e117b9f0485899951051a61d21cdc088d3a5e1ec0e2d018cb257b6edaaf342f5f5304cb229160247ced5ff0fe825f880cb695a201295b4399546de84  lua-cflags.patch
-34db925f9e9a1a629d01dc26072f4edec77087f7bf89dda8140326447662efbc53ce5e36087fa9127d708d498c129613f7ed82862dd3176df16796418868548d  include-luasocket.patch"
+45c80e488fedc879f0217bc8a654d80da003039f5d1ff21b0dea0eb769151787dbe793e44a3dfd72cb07ff2697eceaf4fc7b55b4634cd170fa71281f19f025a5  git.patch
+fb482ad22b5caa2054b25c86edc01d1a666035930f6b55e7d12704dd78b9c31343c39eab5f13958941180d819aa37470c75fe27f1b206a4b431fb589663e2685  lua-cflags.patch"
diff --git a/main/lua-socket/git.patch b/main/lua-socket/git.patch
index 65c5595..d665fc2 100644
--- a/main/lua-socket/git.patch
+++ b/main/lua-socket/git.patch
@@ -1,3 +1,109 @@
+diff --git a/doc/http.html b/doc/http.html
+index cd41c0d..3b7a8b1 100644
+--- a/doc/http.html
+@@ -112,12 +112,15 @@ the HTTP module:
+ </p>
+ 
+ <ul>
+-<li> <tt>PORT</tt>: default port used for connections; 
+-<li> <tt>PROXY</tt>: default proxy used for connections; 
++<li> <tt>PROXY</tt>: default proxy used for connections;
+ <li> <tt>TIMEOUT</tt>: sets the timeout for all I/O operations;
+ <li> <tt>USERAGENT</tt>: default user agent reported to server.
+ </ul>
+ 
++<p class=note id="post">
++Note: These constants are global. Changing them will also
++change the behavior other code that might be using LuaSocket.
++</p>
+ 
+ <!-- http.request ++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+diff --git a/doc/mime.html b/doc/mime.html
+index ae136fd..8cb3507 100644
+--- a/doc/mime.html
+@@ -72,34 +72,6 @@ local mime = require("mime")
+ 
+ <h3 id=high>High-level filters</h3>
+ 
+-<!-- normalize ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class=name id="normalize">
+-mime.<b>normalize(</b>[marker]<b>)</b>
+-</p>
+-
+-<p class=description>
+-Converts most common end-of-line markers to a specific given marker. 
+-</p>
+-
+-<p class=parameters>
+-<tt>Marker</tt> is the new marker. It defaults to CRLF, the canonic 
+-end-of-line marker defined by the MIME standard.
+-</p>
+-
+-<p class=return>
+-The function returns a filter that performs the conversion. 
+-</p>
+-
+-<p class=note>
+-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.
+-</p>
+ 
+ <!-- decode +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+@@ -159,6 +131,35 @@ base64 = ltn12.filter.chain(
+ )
+ </pre>
+ 
++<!-- normalize ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="normalize">
++mime.<b>normalize(</b>[marker]<b>)</b>
++</p>
++
++<p class=description>
++Converts most common end-of-line markers to a specific given marker. 
++</p>
++
++<p class=parameters>
++<tt>Marker</tt> is the new marker. It defaults to CRLF, the canonic 
++end-of-line marker defined by the MIME standard.
++</p>
++
++<p class=return>
++The function returns a filter that performs the conversion. 
++</p>
++
++<p class=note>
++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.
++</p>
++
+ <!-- stuff +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class=name id="stuff">
+@@ -466,7 +467,7 @@ marker.
+ <p>
+ <small>
+ Last modified by Diego Nehab on <br>
+-Thu Apr 20 00:25:44 EDT 2006
++Fri Mar  4 15:19:17 BRT 2016
+ </small>
+ </p>
+ </center>
 diff --git a/doc/reference.css b/doc/reference.css
 index b1dd25d..04e38cf 100644
 --- a/doc/reference.css
@@ -9,7 +115,1821 @@ index b1dd25d..04e38cf 100644
 +    background: #ffffff;
  }
  
- tt {
+ tt {
+diff --git a/doc/reference.html b/doc/reference.html
+index e9bb5eb..287dc19 100644
+--- a/doc/reference.html
+@@ -147,6 +147,7 @@ Support, Manual">
+ <a href="socket.html#connect">connect</a>,
+ <a href="socket.html#connect">connect4</a>,
+ <a href="socket.html#connect">connect6</a>,
++<a href="socket.html#datagramsize">_DATAGRAMSIZE</a>,
+ <a href="socket.html#debug">_DEBUG</a>,
+ <a href="dns.html#dns">dns</a>,
+ <a href="socket.html#gettime">gettime</a>,
+@@ -158,11 +159,14 @@ Support, Manual">
+ <a href="socket.html#skip">skip</a>,
+ <a href="socket.html#sleep">sleep</a>,
+ <a href="socket.html#setsize">_SETSIZE</a>,
++<a href="socket.html#socketinvalid">_SOCKETINVALID</a>,
+ <a href="socket.html#source">source</a>,
+ <a href="tcp.html#socket.tcp">tcp</a>,
++<a href="tcp.html#socket.tcp4">tcp4</a>,
+ <a href="tcp.html#socket.tcp6">tcp6</a>,
+ <a href="socket.html#try">try</a>,
+ <a href="udp.html#socket.udp">udp</a>,
++<a href="udp.html#socket.udp4">udp4</a>,
+ <a href="udp.html#socket.udp6">udp6</a>,
+ <a href="socket.html#version">_VERSION</a>.
+ </blockquote>
+@@ -183,6 +187,7 @@ Support, Manual">
+ <a href="tcp.html#getpeername">getpeername</a>,
+ <a href="tcp.html#getsockname">getsockname</a>,
+ <a href="tcp.html#getstats">getstats</a>,
++<a href="tcp.html#gettimeout">gettimeout</a>,
+ <a href="tcp.html#listen">listen</a>,
+ <a href="tcp.html#receive">receive</a>,
+ <a href="tcp.html#send">send</a>,
+@@ -203,6 +208,7 @@ Support, Manual">
+ <a href="udp.html#getoption">getoption</a>,
+ <a href="udp.html#getpeername">getpeername</a>,
+ <a href="udp.html#getsockname">getsockname</a>,
++<a href="udp.html#gettimeout">gettimeout</a>,
+ <a href="udp.html#receive">receive</a>,
+ <a href="udp.html#receivefrom">receivefrom</a>,
+ <a href="udp.html#send">send</a>,
+diff --git a/doc/smtp.html b/doc/smtp.html
+index bbbff80..600ec37 100644
+--- a/doc/smtp.html
+@@ -114,6 +114,124 @@ the SMTP module:
+ <li> <tt>ZONE</tt>: default time zone.
+ </ul>
+ 
++<!-- message ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id=message> 
++smtp.<b>message(</b>mesgt<b>)</b>
++</p>
++
++<p class=description>
++Returns a <em>simple</em>
++<a href="http://lua-users.org/wiki/FiltersSourcesAndSinks">LTN12</a> source that sends an SMTP message body, possibly multipart (arbitrarily deep). 
++</p>
++
++<p class=parameters>
++The only parameter of the function is a table describing the message.
++<tt>Mesgt</tt> has the following form (notice the recursive structure):
++</p>
++
++<blockquote>
++<table summary="Mesgt table structure">
++<tr><td><tt>
++mesgt = {<br>
++&nbsp;&nbsp;headers = <i>header-table</i>,<br>
++&nbsp;&nbsp;body = <i>LTN12 source</i> or <i>string</i> or 
++<i>multipart-mesgt</i><br>
++}<br>
++&nbsp;<br>
++multipart-mesgt = {<br>
++&nbsp;&nbsp;[preamble = <i>string</i>,]<br>
++&nbsp;&nbsp;[1] = <i>mesgt</i>,<br>
++&nbsp;&nbsp;[2] = <i>mesgt</i>,<br>
++&nbsp;&nbsp;...<br>
++&nbsp;&nbsp;[<i>n</i>] = <i>mesgt</i>,<br>
++&nbsp;&nbsp;[epilogue = <i>string</i>,]<br>
++}<br>
++</tt></td></tr>
++</table>
++</blockquote>
++
++<p class=parameters>
++For a simple message, all that is needed is a set of <tt>headers</tt>
++and the <tt>body</tt>. The message <tt>body</tt> can be given as a string
++or as a <em>simple</em> 
++<a href="http://lua-users.org/wiki/FiltersSourcesAndSinks">LTN12</a> 
++source. For multipart messages, the body is a table that
++recursively defines each part as an independent message, plus an optional
++<tt>preamble</tt> and <tt>epilogue</tt>.
++</p>
++
++<p class=return> 
++The function returns a <em>simple</em> 
++<a href="http://lua-users.org/wiki/FiltersSourcesAndSinks">LTN12</a> 
++source that produces the
++message contents as defined by <tt>mesgt</tt>, chunk by chunk. 
++Hopefully, the following
++example will make things clear. When in doubt, refer to the appropriate RFC
++as listed in the introduction.  </p>
++
++<pre class=example>
++-- 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 &lt;sicrano@example.com&gt;",
++     to = "Fulano da Silva &lt;fulano@example.com&gt;",
++     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 = "&lt;sicrano@example.com&gt;",
++    rcpt = "&lt;fulano@example.com&gt;",
++    source = source,
++}
++</pre>
++
++
+ <!-- send +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class=name id=send> 
+@@ -275,123 +393,6 @@ r, e = smtp.send{
+ }
+ </pre>
+ 
+-<!-- message ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class=name id=message> 
+-smtp.<b>message(</b>mesgt<b>)</b>
+-</p>
+-
+-<p class=description>
+-Returns a <em>simple</em>
+-<a href="http://lua-users.org/wiki/FiltersSourcesAndSinks">LTN12</a> source that sends an SMTP message body, possibly multipart (arbitrarily deep). 
+-</p>
+-
+-<p class=parameters>
+-The only parameter of the function is a table describing the message.
+-<tt>Mesgt</tt> has the following form (notice the recursive structure):
+-</p>
+-
+-<blockquote>
+-<table summary="Mesgt table structure">
+-<tr><td><tt>
+-mesgt = {<br>
+-&nbsp;&nbsp;headers = <i>header-table</i>,<br>
+-&nbsp;&nbsp;body = <i>LTN12 source</i> or <i>string</i> or 
+-<i>multipart-mesgt</i><br>
+-}<br>
+-&nbsp;<br>
+-multipart-mesgt = {<br>
+-&nbsp;&nbsp;[preamble = <i>string</i>,]<br>
+-&nbsp;&nbsp;[1] = <i>mesgt</i>,<br>
+-&nbsp;&nbsp;[2] = <i>mesgt</i>,<br>
+-&nbsp;&nbsp;...<br>
+-&nbsp;&nbsp;[<i>n</i>] = <i>mesgt</i>,<br>
+-&nbsp;&nbsp;[epilogue = <i>string</i>,]<br>
+-}<br>
+-</tt></td></tr>
+-</table>
+-</blockquote>
+-
+-<p class=parameters>
+-For a simple message, all that is needed is a set of <tt>headers</tt>
+-and the <tt>body</tt>. The message <tt>body</tt> can be given as a string
+-or as a <em>simple</em> 
+-<a href="http://lua-users.org/wiki/FiltersSourcesAndSinks">LTN12</a> 
+-source. For multipart messages, the body is a table that
+-recursively defines each part as an independent message, plus an optional
+-<tt>preamble</tt> and <tt>epilogue</tt>.
+-</p>
+-
+-<p class=return> 
+-The function returns a <em>simple</em> 
+-<a href="http://lua-users.org/wiki/FiltersSourcesAndSinks">LTN12</a> 
+-source that produces the
+-message contents as defined by <tt>mesgt</tt>, chunk by chunk. 
+-Hopefully, the following
+-example will make things clear. When in doubt, refer to the appropriate RFC
+-as listed in the introduction.  </p>
+-
+-<pre class=example>
+--- 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 &lt;sicrano@example.com&gt;",
+-     to = "Fulano da Silva &lt;fulano@example.com&gt;",
+-     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 = "&lt;sicrano@example.com&gt;",
+-    rcpt = "&lt;fulano@example.com&gt;",
+-    source = source,
+-}
+-</pre>
+-
+ <!-- footer +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <div class=footer>
+diff --git a/doc/socket.html b/doc/socket.html
+index b9303cb..35f8391 100644
+--- a/doc/socket.html
+@@ -51,6 +51,30 @@ To obtain the <tt>socket</tt> namespace, run:
+ local socket = require("socket")
+ </pre>
+ 
++<!-- headers.canonic ++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="headers.canonic">
++socket.headers.<b>canonic</b></p>
++
++<p> The <tt>socket.headers.canonic</tt> 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.
++</p>
++
++<p> 
++You can obtain the <tt>headers</tt> namespace if case run-time
++modifications are required by running:
++</p>
++
++<pre class=example>
++-- loads the headers module 
++local headers = require("headers")
++</pre>
++
++
+ <!-- bind ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class=name id=bind> 
+@@ -90,7 +114,7 @@ of connect are defined as simple helper functions that restrict the
+ 
+ <!-- debug ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<p class=name id=debug> 
++<p class=name id=debug>
+ socket.<b>_DEBUG</b>
+ </p>
+ 
+@@ -99,6 +123,19 @@ This constant is set to <tt><b>true</b></tt> if the library was compiled
+ with debug support.
+ </p>
+ 
++<!-- datagramsize +++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id=debug>
++socket.<b>_DATAGRAMSIZE</b>
++</p>
++
++<p class=description>
++Default datagram size used by calls to
++<a href="udp.html#receive"<tt>receive</tt></a> and
++<a href="udp.html#receivefrom"><tt>receivefrom</tt></a>.
++(Unless changed in compile time, the value is 8192.)
++</p>
++
+ <!-- get time +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class=name id=gettime> 
+@@ -106,8 +143,7 @@ socket.<b>gettime()</b>
+ </p>
+ 
+ <p class=description>
+-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. 
+ </p>
+ 
+@@ -117,29 +153,6 @@ t = socket.gettime()
+ print(socket.gettime() - t .. " seconds elapsed")
+ </pre>
+ 
+-<!-- socket.headers ++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class=name id="headers.canonic">
+-socket.headers.<b>canonic</b></p>
+-
+-<p> The <tt>socket.headers.canonic</tt> 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.
+-</p>
+-
+-<p> 
+-You can obtain the <tt>headers</tt> namespace if case run-time
+-modifications are required by running:
+-</p>
+-
+-<pre class=example>
+--- loads the headers module 
+-local headers = require("headers")
+-</pre>
+-
+ <!-- newtry +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class=name id=newtry> 
+@@ -155,8 +168,7 @@ is  raised.
+ 
+ <p class=parameters> 
+ <tt>Finalizer</tt> is a function that will be called before
+-<tt>try</tt> throws the exception. It will be called 
+-in <em>protected</em> mode.
++<tt>try</tt> throws the exception.
+ </p>
+ 
+ <p class=return> 
+@@ -204,15 +216,9 @@ to throw exceptions.
+ </p>
+ 
+ <p class=return>
+-Returns an equivalent function that instead of throwing exceptions,
+-returns <tt><b>nil</b></tt> followed by an error message. 
+-</p>
+-
+-<p class=note>
+-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 <a href=#try><tt>try</tt></a> function
+-uses errors as the mechanism to throw exceptions.  
++Returns an equivalent function that instead of throwing exceptions in case of
++a failed <a href=#try><tt>try</tt></a> call, returns <tt><b>nil</b></tt>
++followed by an error message.
+ </p>
+ 
+ <!-- select +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+@@ -238,7 +244,9 @@ non-numeric indices) in the arrays will be silently ignored.
+ 
+ <p class=return> 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 "<tt>timeout</tt>" if a timeout condition was met and
++The error message is "<tt>timeout</tt>" if a timeout
++condition was met, "<tt>select failed</tt>" if the call
++to <tt>select</tt> failed, and
+ <tt><b>nil</b></tt> 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.
+ </p>
+ 
+ <p class=note>
+-<b>Note: </b>: <tt>select</tt> can monitor a limited number
++<b>Note:</b> <tt>select</tt> can monitor a limited number
+ of sockets, as defined by the constant <tt>socket._SETSIZE</tt>. 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 <tt>select</tt>, it will be ignored.
+ <b>Using select with non-socket objects</b>: Any object that implements <tt>getfd</tt> and <tt>dirty</tt> can be used with <tt>select</tt>, allowing objects from other libraries to be used within a <tt>socket.select</tt> driven loop.
+ </p>
+ 
++<!-- setsize ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id=setsize> 
++socket.<b>_SETSIZE</b>
++</p>
++
++<p class=description>
++The maximum number of sockets that the <a
++href=#select><tt>select</tt></a> function can handle. 
++</p>
++
++
+ <!-- sink ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class=name id=sink> 
+@@ -383,15 +403,14 @@ side closes the connection.
+ The function returns a source with the appropriate behavior. 
+ </p>
+ 
+-<!-- setsize ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++<!-- socketinvalid ++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<p class=name id=setsize> 
+-socket.<b>_SETSIZE</b>
++<p class=name id=socketinvalid>
++socket.<b>_SOCKETINVALID</b>
+ </p>
+ 
+ <p class=description>
+-The maximum number of sockets that the <a
+-href=#select><tt>select</tt></a> function can handle. 
++The OS value for an invalid socket.
+ </p>
+ 
+ <!-- try ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+@@ -401,9 +420,9 @@ socket.<b>try(</b>ret<sub>1</sub> [, ret<sub>2</sub> ... ret<sub>N</sub>]<b>)</b
+ </p>
+ 
+ <p class=description>
+-Throws an exception in case of error. The exception can only be caught 
+-by the <a href=#protect><tt>protect</tt></a> function. It does not explode
+-into an error message.
++Throws an exception in case <tt>ret<sub>1</sub></tt> is falsy, using
++<tt>ret<sub>2</sub></tt> as the error message. The exception is supposed to be caught 
++by a <a href=#protect><tt>protect</tt></a>ed function only.
+ </p>
+ 
+ <p class=parameters>
+@@ -414,7 +433,10 @@ nested with <tt>try</tt>.
+ 
+ <p class=return> 
+ The function returns <tt>ret</tt><sub>1</sub> to <tt>ret</tt><sub>N</sub> if
+-<tt>ret</tt><sub>1</sub> is not <tt><b>nil</b></tt>. Otherwise, it calls <tt>error</tt> passing <tt>ret</tt><sub>2</sub>.
++<tt>ret</tt><sub>1</sub> is not <tt><b>nil</b></tt> or <tt><b>false</b></tt>.
++Otherwise, it calls <tt>error</tt> passing <tt>ret</tt><sub>2</sub> wrapped
++in a table with metatable used by <a href=#protect><tt>protect</tt></a> to
++distinguish exceptions from runtime errors.
+ </p>
+ 
+ <pre class=example>
+diff --git a/doc/tcp.html b/doc/tcp.html
+index 4226d78..c6c6eb2 100644
+--- a/doc/tcp.html
+@@ -1,10 +1,10 @@
+-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
++<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+     "http://www.w3.org/TR/html4/strict.dtd">
+ <html>
+ 
+ <head>
+ <meta name="description" content="LuaSocket: The TCP/IP support">
+-<meta name="keywords" content="Lua, LuaSocket, Socket, TCP, Library, Network, Support"> 
++<meta name="keywords" content="Lua, LuaSocket, Socket, TCP, Library, Network, Support">
+ <title>LuaSocket: TCP/IP support</title>
+ <link rel="stylesheet" href="reference.css" type="text/css">
+ </head>
+@@ -28,7 +28,7 @@
+ <a href="index.html#download">download</a> &middot;
+ <a href="installation.html">installation</a> &middot;
+ <a href="introduction.html">introduction</a> &middot;
+-<a href="reference.html">reference</a> 
++<a href="reference.html">reference</a>
+ </p>
+ </center>
+ <hr>
+@@ -36,56 +36,11 @@
+ 
+ <!-- tcp ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<h2 id="tcp">TCP</h2> 
+-
+-<!-- socket.tcp +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class=name id="socket.tcp"> 
+-socket.<b>tcp()</b>
+-</p>
+-
+-<p class=description> 
+-Creates and returns an IPv4 TCP master object. A master object can
+-be transformed into a server object with the method 
+-<a href=#listen><tt>listen</tt></a> (after a call to <a
+-href=#bind><tt>bind</tt></a>) or into a client object with 
+-the method <a href=#connect><tt>connect</tt></a>. The only other 
+-method supported by a master object is the 
+-<a href=#close><tt>close</tt></a> method.</p>
+-
+-<p class=return>
+-In case of success, a new master object is returned. In case of error,
+-<b><tt>nil</tt></b> is returned, followed by an error message.
+-</p>
+-
+-<!-- socket.tcp6 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class=name id="socket.tcp6"> 
+-socket.<b>tcp6()</b>
+-</p>
+-
+-<p class=description> 
+-Creates and returns an IPv6 TCP master object. A master object can
+-be transformed into a server object with the method 
+-<a href=#listen><tt>listen</tt></a> (after a call to <a
+-href=#bind><tt>bind</tt></a>) or into a client object with 
+-the method <a href=#connect><tt>connect</tt></a>. The only other 
+-method supported by a master object is the 
+-<a href=#close><tt>close</tt></a> method.</p>
+-
+-<p class=return>
+-In case of success, a new master object is returned. In case of error,
+-<b><tt>nil</tt></b> is returned, followed by an error message.
+-</p>
+-
+-<p class=note>
+-Note: The TCP object returned will have the option
+-"<tt>ipv6-v6only</tt>" set to <tt><b>true</b></tt>.
+-</p>
++<h2 id="tcp">TCP</h2>
+ 
+ <!-- accept +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<p class=name id="accept"> 
++<p class=name id="accept">
+ server:<b>accept()</b>
+ </p>
+ 
+@@ -95,9 +50,9 @@ object and returns a client object representing that connection.
+ </p>
+ 
+ <p class=return>
+-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 <b><tt>nil</tt></b>
+-followed by the error string '<tt>timeout</tt>'. Other errors are 
++followed by the error string '<tt>timeout</tt>'. Other errors are
+ reported by <b><tt>nil</tt></b> followed by a message describing the error.
+ </p>
+ 
+@@ -107,28 +62,28 @@ with   a  server   object   in
+ the <tt>recvt</tt>  parameter  before  a   call  to  <tt>accept</tt> does
+ <em>not</em> guarantee  <tt>accept</tt> will  return immediately.  Use the <a
+ href=#settimeout><tt>settimeout</tt></a> method or <tt>accept</tt>
+-might block until <em>another</em> client shows up. 
++might block until <em>another</em> client shows up.
+ </p>
+ 
+ <!-- bind +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<p class=name id="bind"> 
++<p class=name id="bind">
+ master:<b>bind(</b>address, port<b>)</b>
+ </p>
+ 
+ <p class=description>
+ Binds a master object to <tt>address</tt> and <tt>port</tt> on the
+-local host. 
++local host.
+ 
+ <p class=parameters>
+-<tt>Address</tt> can be an IP address or a host name. 
+-<tt>Port</tt> must be an integer number in the range [0..64K). 
++<tt>Address</tt> can be an IP address or a host name.
++<tt>Port</tt> must be an integer number in the range [0..64K).
+ If <tt>address</tt>
+ is '<tt>*</tt>', the system binds to all local interfaces
+ using the <tt>INADDR_ANY</tt> constant or
+-<tt>IN6ADDR_ANY_INIT</tt>, according to the family. 
++<tt>IN6ADDR_ANY_INIT</tt>, according to the family.
+ If <tt>port</tt> is 0, the system automatically
+-chooses an ephemeral port.  
++chooses an ephemeral port.
+ </p>
+ 
+ <p class=return>
+@@ -137,13 +92,13 @@ method returns <b><tt>nil</tt></b> followed by an error message.
+ </p>
+ 
+ <p class=note>
+-Note: The function <a href=socket.html#bind><tt>socket.bind</tt></a> 
++Note: The function <a href=socket.html#bind><tt>socket.bind</tt></a>
+ is available and is a shortcut for the creation of server sockets.
+ </p>
+ 
+ <!-- close ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<p class=name id="close"> 
++<p class=name id="close">
+ master:<b>close()</b><br>
+ client:<b>close()</b><br>
+ server:<b>close()</b>
+@@ -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 <tt>close</tt> method)  are allowed on
+-a closed socket. 
++a closed socket.
+ </p>
+ 
+ <p class=note>
+ 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.
+ </p>
+ 
+ <!-- connect ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+@@ -172,19 +127,19 @@ master:<b>connect(</b>address, port<b>)</b>
+ 
+ <p class=description>
+ 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
+ <a href=#send><tt>send</tt></a>,
+-<a href=#receive><tt>receive</tt></a>, 
+-<a href=#getsockname><tt>getsockname</tt></a>, 
++<a href=#receive><tt>receive</tt></a>,
++<a href=#getsockname><tt>getsockname</tt></a>,
+ <a href=#getpeername><tt>getpeername</tt></a>,
+-<a href=#settimeout><tt>settimeout</tt></a>, 
++<a href=#settimeout><tt>settimeout</tt></a>,
+ and <a href=#close><tt>close</tt></a>.
+ </p>
+ 
+ <p class=parameters>
+-<tt>Address</tt> can be an IP address or a host name. 
+-<tt>Port</tt> must be an integer number in the range [1..64K). 
++<tt>Address</tt> can be an IP address or a host name.
++<tt>Port</tt> must be an integer number in the range [1..64K).
+ </p>
+ 
+ <p class=return>
+@@ -193,14 +148,14 @@ describing the error. In case of success, the method returns 1.
+ </p>
+ 
+ <p class=note>
+-Note: The function <a href=socket.html#connect><tt>socket.connect</tt></a> 
++Note: The function <a href=socket.html#connect><tt>socket.connect</tt></a>
+ is available and is a shortcut for the creation of client sockets.
+ </p>
+ 
+ <p class=note>
+-Note: Starting with LuaSocket 2.0, 
++Note: Starting with LuaSocket 2.0,
+ the <a href=#settimeout><tt>settimeout</tt></a>
+-method affects the behavior of <tt>connect</tt>, causing it to return 
++method affects the behavior of <tt>connect</tt>, causing it to return
+ with an error in case of a timeout. If that happens, you can still call <a
+ href=socket.html#select><tt>socket.select</tt></a> with the socket in the
+ <tt>sendt</tt> table. The socket will be writable when the connection is
+@@ -209,13 +164,88 @@ established.
+ 
+ <p class=note>
+ Note: Starting with LuaSocket 3.0, the host name resolution
+-depends on whether the socket was created by <a
+-href=#socket.tcp><tt>socket.tcp</tt></a> or <a
+-href=#socket.tcp6><tt>socket.tcp6</tt></a>. 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
++<a href=#socket.tcp><tt>socket.tcp</tt></a>,
++<a href=#socket.tcp4><tt>socket.tcp4</tt></a> or
++<a href=#socket.tcp6><tt>socket.tcp6</tt></a>. 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.
++</p>
++
++<!-- dirty +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="dirty">
++master:<b>dirty()</b><br>
++client:<b>dirty()</b><br>
++server:<b>dirty()</b>
++</p>
++
++<p class=description>
++Check the read buffer status.
++</p>
++
++<p class=return>
++Returns <tt>true</tt> if there is any data in the read buffer, <tt>false</tt> otherwise.
++</p>
++
++<p class=note>
++Note: <b>This is an internal method, use at your own risk.</b>
++</p>
++
++
++<!-- getfd +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="getfd">
++master:<b>getfd()</b><br>
++client:<b>getfd()</b><br>
++server:<b>getfd()</b>
++</p>
++
++<p class=description>
++Returns the underling socket descriptor or handle associated to the object.
++</p>
++
++<p class=return>
++The descriptor or handle. In case the object has been closed, the return will be -1.
++</p>
++
++<p class=note>
++Note: <b>This is an internal method. Unlikely to be
++portable. Use at your own risk. </b>
++</p>
++
++
++<!-- getoption ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="getoption">
++client:<b>getoption(</b>option)</b><br>
++server:<b>getoption(</b>option)</b>
++</p>
++
++<p class=description>
++Gets options for the TCP object.
++See <a href=#setoption><tt>setoption</tt></a> for description of the
++option names and values.
++</p>
++
++<p class=parameters>
++<tt>Option</tt> is a string with the option name.
++<ul>
++
++<li> '<tt>keepalive</tt>'
++<li> '<tt>linger</tt>'
++<li> '<tt>reuseaddr</tt>'
++<li> '<tt>tcp-nodelay</tt>'
++</ul>
++
++<p class=return>
++The method returns the option <tt>value</tt> in case of success, or
++<b><tt>nil</tt></b> followed by an error message otherwise.
+ </p>
+ 
++
+ <!-- getpeername ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class=name id="getpeername">
+@@ -227,10 +257,10 @@ Returns information about the remote side of a connected client object.
+ </p>
+ 
+ <p class=return>
+-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 ("<tt>inet</tt>" or "<tt>inet6</tt>"). 
+-In case of error, the method returns <b><tt>nil</tt></b>. 
++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 ("<tt>inet</tt>" or "<tt>inet6</tt>").
++In case of error, the method returns <b><tt>nil</tt></b>.
+ </p>
+ 
+ <p class=note>
+@@ -246,13 +276,13 @@ server:<b>getsockname()</b>
+ </p>
+ 
+ <p class=description>
+-Returns the local address information associated to the object. 
++Returns the local address information associated to the object.
+ </p>
+ 
+ <p class=return>
+-The method returns a string with local IP address, a number with 
+-the local port, 
+-and a string with the family ("<tt>inet</tt>" or "<tt>inet6</tt>"). 
++The method returns a string with local IP address, a number with
++the local port,
++and a string with the family ("<tt>inet</tt>" or "<tt>inet6</tt>").
+ In case of error, the method returns <b><tt>nil</tt></b>.
+ </p>
+ 
+@@ -266,32 +296,46 @@ server:<b>getstats()</b><br>
+ 
+ <p class=description>
+ Returns accounting information on the socket, useful for throttling
+-of bandwidth. 
++of bandwidth.
+ </p>
+ 
+ <p class=return>
+ 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.
+ </p>
+ 
++<!-- gettimeout +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="gettimeout">
++master:<b>gettimeout()</b><br>
++client:<b>gettimeout()</b><br>
++server:<b>gettimeout()</b>
++</p>
++
++<p class=description>
++Returns the current block timeout followed by the curent
++total timeout.
++</p>
++
++
+ <!-- listen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<p class=name id="listen"> 
++<p class=name id="listen">
+ master:<b>listen(</b>backlog<b>)</b>
+ </p>
+ 
+ <p class=description>
+ Specifies the socket is willing to receive connections, transforming the
+-object into a server object.  Server objects support the 
+-<a href=#accept><tt>accept</tt></a>,  
+-<a href=#getsockname><tt>getsockname</tt></a>, 
+-<a href=#setoption><tt>setoption</tt></a>, 
+-<a href=#settimeout><tt>settimeout</tt></a>, 
+-and <a href=#close><tt>close</tt></a> methods.  
++object into a server object.  Server objects support the
++<a href=#accept><tt>accept</tt></a>,
++<a href=#getsockname><tt>getsockname</tt></a>,
++<a href=#setoption><tt>setoption</tt></a>,
++<a href=#settimeout><tt>settimeout</tt></a>,
++and <a href=#close><tt>close</tt></a> methods.
+ </p>
+ 
+ <p class=parameters>
+-The parameter <tt>backlog</tt> specifies the  number  of  client 
++The parameter <tt>backlog</tt> 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:<b>receive(</b>[pattern [, prefix]]<b>)</b>
+ 
+ <p class=description>
+ Reads data from a client object, according to the specified <em>read
+-pattern</em>.  Patterns follow the Lua file I/O format, and the difference in performance between all patterns is negligible. 
++pattern</em>.  Patterns follow the Lua file I/O format, and the difference in performance between all patterns is negligible.
+ </p>
+ 
+ <p class=parameters>
+-<tt>Pattern</tt> can be any of the following: 
++<tt>Pattern</tt> can be any of the following:
+ </p>
+ 
+ <ul>
+@@ -325,7 +369,7 @@ terminated by a  LF character (ASCII&nbsp;10), optionally  preceded by a
+ CR character (ASCII&nbsp;13). The CR and LF characters are not included in
+ the returned line. In fact, <em>all</em> CR characters are
+ ignored by the pattern. This is the default pattern;
+-<li> <tt>number</tt>:  causes the  method to read  a specified <tt>number</tt> 
++<li> <tt>number</tt>:  causes the  method to read  a specified <tt>number</tt>
+ of bytes from the socket.
+ </ul>
+ 
+@@ -347,10 +391,10 @@ closed  before  the transmission  was completed  or  the string
+ <p class=note>
+ <b>Important note</b>: This function was changed <em>severely</em>. 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 <tt><b>nil</b></tt> on error.  Thus it was changed
+-too. 
++too.
+ </p>
+ 
+ <!-- send +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+@@ -366,7 +410,7 @@ Sends <tt>data</tt> through client object.
+ <p class=parameters>
+ <tt>Data</tt> is the string to be sent. The optional arguments
+ <tt>i</tt> and <tt>j</tt> work exactly like the standard
+-<tt>string.sub</tt> Lua function to allow the selection of a 
++<tt>string.sub</tt> Lua function to allow the selection of a
+ substring to be sent.
+ </p>
+ 
+@@ -385,10 +429,10 @@ there was  a  timeout  during  the operation.
+ </p>
+ 
+ <p class=note>
+-Note: Output is <em>not</em> buffered. For small strings, 
+-it is always better to concatenate them in Lua 
+-(with the '<tt>..</tt>' operator) and send the result in one call 
+-instead of calling the method several times. 
++Note: Output is <em>not</em> buffered. For small strings,
++it is always better to concatenate them in Lua
++(with the '<tt>..</tt>' operator) and send the result in one call
++instead of calling the method several times.
+ </p>
+ 
+ <!-- setoption ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+@@ -400,12 +444,12 @@ server:<b>setoption(</b>option [, value]<b>)</b>
+ 
+ <p class=description>
+ 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.
+ </p>
+ 
+ <p class=parameters>
+-<tt>Option</tt> is a string with the option name, and <tt>value</tt> 
++<tt>Option</tt> is a string with the option name, and <tt>value</tt>
+ depends on the option being set:
+ 
+ <ul>
+@@ -413,7 +457,7 @@ depends on the option being set:
+ <li> '<tt>keepalive</tt>':  Setting this option to <tt>true</tt> 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;
+ 
+ <li> '<tt>linger</tt>': 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 '<tt>timeout</tt>' has passed. If
+ '<tt>on</tt>' is <tt>false</tt> 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;
+ 
+ <li> '<tt>reuseaddr</tt>': 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
+ <a href=#bind><tt>bind</tt></a> should allow reuse of local addresses;
+ 
+-<li> '<tt>tcp-nodelay</tt>': Setting this option to <tt>true</tt> 
++<li> '<tt>tcp-nodelay</tt>': Setting this option to <tt>true</tt>
+ disables the Nagle's algorithm for the connection;
+ 
+ <li> '<tt>ipv6-v6only</tt>':
+@@ -447,34 +491,6 @@ followed by an error message otherwise.
+ Note: The descriptions above come from the man pages.
+ </p>
+ 
+-<!-- getoption ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class=name id="getoption">
+-client:<b>getoption(</b>option)</b><br>
+-server:<b>getoption(</b>option)</b>
+-</p>
+-
+-<p class=description>
+-Gets options for the TCP object.
+-See <a href=#setoption><tt>setoption</tt></a> for description of the
+-option names and values.
+-</p>
+-
+-<p class=parameters>
+-<tt>Option</tt> is a string with the option name.
+-<ul>
+-
+-<li> '<tt>keepalive</tt>'
+-<li> '<tt>linger</tt>'
+-<li> '<tt>reuseaddr</tt>'
+-<li> '<tt>tcp-nodelay</tt>'
+-</ul>
+-
+-<p class=return>
+-The method returns the option <tt>value</tt> in case of success, or
+-<b><tt>nil</tt></b> followed by an error message otherwise.
+-</p>
+-
+ <!-- setstats +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class=name id="setstats">
+@@ -485,7 +501,7 @@ server:<b>setstats(</b>received, sent, age<b>)</b><br>
+ 
+ <p class=description>
+ Resets accounting information on the socket, useful for throttling
+-of bandwidth. 
++of bandwidth.
+ </p>
+ 
+ <p class=parameters>
+@@ -495,7 +511,7 @@ of bandwidth.
+ </p>
+ 
+ <p class=return>
+-The method returns 1 in case of success and <tt><b>nil</b></tt> otherwise. 
++The method returns 1 in case of success and <tt><b>nil</b></tt> otherwise.
+ </p>
+ 
+ <!-- settimeout +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+@@ -509,8 +525,8 @@ server:<b>settimeout(</b>value [, mode]<b>)</b>
+ <p class=description>
+ Changes the timeout  values for the object. By default,
+ all I/O  operations are  blocking. That  is, any  call to  the methods
+-<a href=#send><tt>send</tt></a>, 
+-<a href=#receive><tt>receive</tt></a>, and 
++<a href=#send><tt>send</tt></a>,
++<a href=#receive><tt>receive</tt></a>, and
+ <a href=#accept><tt>accept</tt></a>
+ will  block indefinitely,  until the operation completes.  The
+ <tt>settimeout</tt>  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.
+ <p class=parameters>
+ The amount of time to wait is specified  as  the
+ <tt>value</tt> 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:
+ </p>
+ 
+ <ul>
+@@ -532,7 +548,7 @@ default mode;</li>
+ 
+ <li> '<tt>t</tt>':  <em>total</em> timeout. Specifies the  upper limit on
+ the amount of  time LuaSocket can block a Lua  script before returning from
+-a call.</li> 
++a call.</li>
+ </ul>
+ 
+ <p class=parameters>
+@@ -562,7 +578,7 @@ client:<b>shutdown(</b>mode<b>)</b><br>
+ </p>
+ 
+ <p class=description>
+-Shuts down part of a full-duplex connection. 
++Shuts down part of a full-duplex connection.
+ </p>
+ 
+ <p class=parameters>
+@@ -579,66 +595,107 @@ This is the default mode;
+ This function returns 1.
+ </p>
+ 
+-<!-- dirty +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++<!-- setfd +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<p class=name id="dirty">
+-master:<b>dirty()</b><br>
+-client:<b>dirty()</b><br>
+-server:<b>dirty()</b>
++<p class=name id="setfd">
++master:<b>setfd(</b>fd<b>)</b><br>
++client:<b>setfd(</b>fd<b>)</b><br>
++server:<b>setfd(</b>fd<b>)</b>
+ </p>
+ 
+ <p class=description>
+-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.
+ </p>
+ 
+ <p class=return>
+-Returns <tt>true</tt> if there is any data in the read buffer, <tt>false</tt> otherwise.
++No return value.
+ </p>
+ 
+ <p class=note>
+-Note: <b>This is an internal method, any use is unlikely to be portable.</b>
++Note: <b>This is an internal method. Unlikely to be
++portable. Use at your own risk. </b>
+ </p>
+ 
+-<!-- getfd +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++<!-- socket.tcp +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<p class=name id="getfd">
+-master:<b>getfd()</b><br>
+-client:<b>getfd()</b><br>
+-server:<b>getfd()</b>
++<p class=name id="socket.tcp">
++socket.<b>tcp()</b>
+ </p>
+ 
+ <p class=description>
+-Returns the underling socket descriptor or handle associated to the object. 
+-</p>
++Creates and returns an TCP master object. A master object can
++be transformed into a server object with the method
++<a href=#listen><tt>listen</tt></a> (after a call to <a
++href=#bind><tt>bind</tt></a>) or into a client object with
++the method <a href=#connect><tt>connect</tt></a>. The only other
++method supported by a master object is the
++<a href=#close><tt>close</tt></a> method.</p>
+ 
+ <p class=return>
+-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,
++<b><tt>nil</tt></b> is returned, followed by an error message.
+ </p>
+ 
+ <p class=note>
+-Note: <b>This is an internal method, any use is unlikely to be portable.</b>
++Note: The choice between IPv4 and IPv6 happens during a call to
++<a href=#bind><tt>bind</tt></a> or <a
++href=#bind><tt>connect</tt></a>, depending on the address
++family obtained from the resolver.
+ </p>
+ 
+-<!-- setfd +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++<p class=note>
++Note: Before the choice between IPv4 and IPv6 happens,
++the internal socket object is invalid and therefore <a
++href=#setoption><tt>setoption</tt></a> will fail.
++</p>
+ 
+-<p class=name id="setfd">
+-master:<b>setfd(</b>fd<b>)</b><br>
+-client:<b>setfd(</b>fd<b>)</b><br>
+-server:<b>setfd(</b>fd<b>)</b>
++<!-- socket.tcp +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="socket.tcp4">
++socket.<b>tcp4()</b>
+ </p>
+ 
+ <p class=description>
+-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
++<a href=#listen><tt>listen</tt></a> (after a call to <a
++href=#bind><tt>bind</tt></a>) or into a client object with
++the method <a href=#connect><tt>connect</tt></a>. The only other
++method supported by a master object is the
++<a href=#close><tt>close</tt></a> method.</p>
++
++<p class=return>
++In case of success, a new master object is returned. In case of error,
++<b><tt>nil</tt></b> is returned, followed by an error message.
++</p>
++
++<!-- socket.tcp6 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="socket.tcp6">
++socket.<b>tcp6()</b>
+ </p>
+ 
++<p class=description>
++Creates and returns an IPv6 TCP master object. A master object can
++be transformed into a server object with the method
++<a href=#listen><tt>listen</tt></a> (after a call to <a
++href=#bind><tt>bind</tt></a>) or into a client object with
++the method <a href=#connect><tt>connect</tt></a>. The only other
++method supported by a master object is the
++<a href=#close><tt>close</tt></a> method.</p>
++
+ <p class=return>
+-No return value.
++In case of success, a new master object is returned. In case of error,
++<b><tt>nil</tt></b> is returned, followed by an error message.
+ </p>
+ 
+ <p class=note>
+-Note: <b>This is an internal method, any use is unlikely to be portable.</b>
++Note: The TCP object returned will have the option
++"<tt>ipv6-v6only</tt>" set to <tt><b>true</b></tt>.
+ </p>
+ 
++
++
+ <!-- footer +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <div class=footer>
+diff --git a/doc/udp.html b/doc/udp.html
+index e5b0ad0..4618aad 100644
+--- a/doc/udp.html
+@@ -4,7 +4,7 @@
+ 
+ <head>
+ <meta name="description" content="LuaSocket: The UDP support">
+-<meta name="keywords" content="Lua, LuaSocket, Socket, UDP, Library, Network, Support"> 
++<meta name="keywords" content="Lua, LuaSocket, Socket, UDP, Library, Network, Support">
+ <title>LuaSocket: UDP support</title>
+ <link rel="stylesheet" href="reference.css" type="text/css">
+ </head>
+@@ -28,7 +28,7 @@
+ <a href="index.html#download">download</a> &middot;
+ <a href="installation.html">installation</a> &middot;
+ <a href="introduction.html">introduction</a> &middot;
+-<a href="reference.html">reference</a> 
++<a href="reference.html">reference</a>
+ </p>
+ </center>
+ <hr>
+@@ -37,74 +37,7 @@
+ 
+ <!-- udp ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+-<h2 id="udp">UDP</h2> 
+-
+-<!-- socket.udp ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class="name" id="socket.udp">
+-socket.<b>udp()</b>
+-</p>
+-
+-<p class="description">
+-Creates and returns an unconnected IPv4 UDP object. 
+-Unconnected objects support the 
+-<a href="#sendto"><tt>sendto</tt></a>, 
+-<a href="#receive"><tt>receive</tt></a>, 
+-<a href="#receivefrom"><tt>receivefrom</tt></a>, 
+-<a href="#getoption"><tt>getoption</tt></a>, 
+-<a href="#getsockname"><tt>getsockname</tt></a>, 
+-<a href="#setoption"><tt>setoption</tt></a>, 
+-<a href="#settimeout"><tt>settimeout</tt></a>, 
+-<a href="#setpeername"><tt>setpeername</tt></a>, 
+-<a href="#setsockname"><tt>setsockname</tt></a>, and 
+-<a href="#close"><tt>close</tt></a>. 
+-The <a href="#setpeername"><tt>setpeername</tt></a> 
+-is used to connect the object.
+-</p>
+-
+-<p class="return">
+-In case of success, a new unconnected UDP object
+-returned. In case of error, <b><tt>nil</tt></b> is returned, followed by
+-an error message.
+-</p>
+-
+-<!-- socket.udp ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class="name" id="socket.udp6">
+-socket.<b>udp6()</b>
+-</p>
+-
+-<p class="description">
+-Creates and returns an unconnected IPv6 UDP object. 
+-Unconnected objects support the 
+-<a href="#sendto"><tt>sendto</tt></a>, 
+-<a href="#receive"><tt>receive</tt></a>, 
+-<a href="#receivefrom"><tt>receivefrom</tt></a>, 
+-<a href="#getoption"><tt>getoption</tt></a>, 
+-<a href="#getsockname"><tt>getsockname</tt></a>, 
+-<a href="#setoption"><tt>setoption</tt></a>, 
+-<a href="#settimeout"><tt>settimeout</tt></a>, 
+-<a href="#setpeername"><tt>setpeername</tt></a>, 
+-<a href="#setsockname"><tt>setsockname</tt></a>, and 
+-<a href="#close"><tt>close</tt></a>. 
+-The <a href="#setpeername"><tt>setpeername</tt></a> 
+-is used to connect the object.
+-</p>
+-
+-<p class="return">
+-In case of success, a new unconnected UDP object
+-returned. In case of error, <b><tt>nil</tt></b> is returned, followed by
+-an error message.
+-</p>
+-
+-<p class=note>
+-Note: The TCP object returned will have the option
+-"<tt>ipv6-v6only</tt>" set to <tt><b>true</b></tt>.
+-</p>
+-
+-
+-
+-<!-- close +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++<h2 id="udp">UDP</h2>
+ 
+ <!-- close +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+@@ -129,6 +62,40 @@ Garbage-collected objects are automatically closed before
+ destruction, though.
+ </p>
+ 
++<!-- getoption +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class="name" id="getoption">
++connected:<b>getoption()</b><br>
++unconnected:<b>getoption()</b>
++</p>
++
++<p class="description">
++Gets an option value from the UDP object.
++See <a href=#setoption><tt>setoption</tt></a> for
++description of the option names and values.
++</p>
++
++<p class="parameters"><tt>Option</tt> is a string with the option name.
++<ul>
++<li> '<tt>dontroute</tt>'
++<li> '<tt>broadcast</tt>'
++<li> '<tt>reuseaddr</tt>'
++<li> '<tt>reuseport</tt>'
++<li> '<tt>ip-multicast-loop</tt>'
++<li> '<tt>ipv6-v6only</tt>'
++<li> '<tt>ip-multicast-if</tt>'
++<li> '<tt>ip-multicast-ttl</tt>'
++<li> '<tt>ip-add-membership</tt>'
++<li> '<tt>ip-drop-membership</tt>'
++</ul>
++</p>
++
++<p class=return>
++The method returns the option <tt>value</tt> in case of
++success, or
++<b><tt>nil</tt></b> followed by an error message otherwise.
++</p>
++
+ <!-- getpeername +++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class="name" id="getpeername">
+@@ -142,10 +109,10 @@ associated with a connected UDP object.
+ 
+ 
+ <p class=return>
+-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 ("<tt>inet</tt>" or "<tt>inet6</tt>"). 
+-In case of error, the method returns <b><tt>nil</tt></b>. 
++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 ("<tt>inet</tt>" or "<tt>inet6</tt>").
++In case of error, the method returns <b><tt>nil</tt></b>.
+ </p>
+ 
+ <p class="note">
+@@ -165,9 +132,9 @@ Returns the local address information associated to the object.
+ 
+ 
+ <p class=return>
+-The method returns a string with local IP address, a number with 
+-the local port, 
+-and a string with the family ("<tt>inet</tt>" or "<tt>inet6</tt>"). 
++The method returns a string with local IP address, a number with
++the local port,
++and a string with the family ("<tt>inet</tt>" or "<tt>inet6</tt>").
+ In case of error, the method returns <b><tt>nil</tt></b>.
+ </p>
+ 
+@@ -179,6 +146,18 @@ first time (in which case it is bound to an ephemeral port and the
+ wild-card address).
+ </p>
+ 
++<!-- gettimeout +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class=name id="gettimeout">
++connected:<b>settimeout(</b>value<b>)</b><br>
++unconnected:<b>settimeout(</b>value<b>)</b>
++</p>
++
++<p class=description>
++Returns the current timeout value.
++</p>
++
++
+ <!-- receive +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class="name" id="receive">
+@@ -199,9 +178,12 @@ specifies the maximum size of the datagram to be retrieved. If
+ there are more than <tt>size</tt> bytes available in the datagram,
+ the excess bytes are discarded. If there are less then
+ <tt>size</tt> bytes available in the current datagram, the
+-available bytes are returned. If <tt>size</tt> is omitted, the
+-maximum datagram size is used (which is currently limited by the
+-implementation to 8192 bytes).
++available bytes are returned.
++If <tt>size</tt> is omitted, the
++compile-time constant <a
++href=socket.html#datagramsize><tt>socket._DATAGRAMSIZE</tt></a> is used
++(it defaults to 8192 bytes). Larger sizes will cause a
++temporary buffer to be allocated for the operation.
+ </p>
+ 
+ <p class="return">
+@@ -217,46 +199,12 @@ unconnected:<b>receivefrom(</b>[size]<b>)</b>
+ </p>
+ 
+ <p class="description">
+-Works exactly as the <a href="#receive"><tt>receive</tt></a> 
++Works exactly as the <a href="#receive"><tt>receive</tt></a>
+ method, except it returns the IP
+ address and port as extra return values (and is therefore slightly less
+ efficient).
+ </p>
+ 
+-<!-- getoption +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class="name" id="getoption">
+-connected:<b>getoption()</b><br>
+-unconnected:<b>getoption()</b>
+-</p>
+-
+-<p class="description">
+-Gets an option value from the UDP object.
+-See <a href=#setoption><tt>setoption</tt></a> for
+-description of the option names and values.
+-</p>
+-
+-<p class="parameters"><tt>Option</tt> is a string with the option name. 
+-<ul>
+-<li> '<tt>dontroute</tt>'
+-<li> '<tt>broadcast</tt>'
+-<li> '<tt>reuseaddr</tt>'
+-<li> '<tt>reuseport</tt>'
+-<li> '<tt>ip-multicast-loop</tt>'
+-<li> '<tt>ipv6-v6only</tt>'
+-<li> '<tt>ip-multicast-if</tt>'
+-<li> '<tt>ip-multicast-ttl</tt>'
+-<li> '<tt>ip-add-membership</tt>' 
+-<li> '<tt>ip-drop-membership</tt>'
+-</ul> 
+-</p>
+-
+-<p class=return>
+-The method returns the option <tt>value</tt> in case of
+-success, or
+-<b><tt>nil</tt></b> followed by an error message otherwise.
+-</p>
+-
+ <!-- send ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class="name" id="send">
+@@ -268,7 +216,7 @@ Sends a datagram to the UDP peer of a connected object.
+ </p>
+ 
+ <p class="parameters">
+-<tt>Datagram</tt> is a string with the datagram contents. 
++<tt>Datagram</tt> 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.
+ 
+ <p class="parameters">
+ <tt>Datagram</tt> 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.
+-<tt>Ip</tt> is the IP address of the recipient. 
++<tt>Ip</tt> is the IP address of the recipient.
+ Host names are <em>not</em> allowed for performance reasons.
+ 
+ <tt>Port</tt> 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).
+ </p>
+ 
++<!-- setoption +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class="name" id="setoption">
++connected:<b>setoption(</b>option [, value]<b>)</b><br>
++unconnected:<b>setoption(</b>option [, value]<b>)</b>
++</p>
++
++<p class="description">
++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.</p>
++<p class="parameters"><tt>Option</tt> is a string with the option
++name, and <tt>value</tt> depends on the option being set:
++</p>
++
++<ul>
++<li> '<tt>dontroute</tt>': Indicates that outgoing
++messages should bypass the standard routing facilities.
++Receives a boolean value;
++<li> '<tt>broadcast</tt>': Requests permission to send
++broadcast datagrams on the socket.
++Receives a boolean value;
++<li> '<tt>reuseaddr</tt>': Indicates that the rules used in
++validating addresses supplied in a <tt>bind()</tt> call
++should allow reuse of local addresses.
++Receives a boolean value;
++<li> '<tt>reuseport</tt>': Allows completely duplicate
++bindings by multiple processes if they all set
++'<tt>reuseport</tt>' before binding the port.
++Receives a boolean value;
++<li> '<tt>ip-multicast-loop</tt>':
++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;
++<li> '<tt>ipv6-v6only</tt>':
++Specifies whether to restrict <tt>inet6</tt> sockets to
++sending and receiving only IPv6 packets.
++Receive a boolean value;
++<li> '<tt>ip-multicast-if</tt>':
++Sets the interface over which outgoing multicast datagrams
++are sent.
++Receives an IP address;
++<li> '<tt>ip-multicast-ttl</tt>':
++Sets the Time To Live in the IP header for outgoing
++multicast datagrams.
++Receives a number;
++<li> '<tt>ip-add-membership</tt>':
++Joins the multicast group specified.
++Receives a table with fields
++<tt>multiaddr</tt> and <tt>interface</tt>, each containing an
++IP address;
++<li> '<tt>ip-drop-membership</tt>': Leaves the multicast
++group specified.
++Receives a table with fields
++<tt>multiaddr</tt> and <tt>interface</tt>, each containing an
++IP address.
++</ul>
++
++<p class="return">
++The method returns 1 in case of success, or
++<b><tt>nil</tt></b> followed by an error message otherwise.
++</p>
++
++<p class=note>
++Note: The descriptions above come from the man pages.
++</p>
++
++
+ <!-- setpeername +++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class="name" id="setpeername">
+@@ -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 <a href="#send"><tt>send</tt></a> and 
+-<a href="#receive"><tt>receive</tt></a> methods instead of 
+-<a href="#sendto"><tt>sendto</tt></a> and 
++use the <a href="#send"><tt>send</tt></a> and
++<a href="#receive"><tt>receive</tt></a> methods instead of
++<a href="#sendto"><tt>sendto</tt></a> and
+ <a href="#receivefrom"><tt>receivefrom</tt></a>.
+ </p>
+ 
+@@ -406,74 +423,6 @@ system or explicitly by <tt>setsockname</tt>, it cannot be
+ changed.
+ </p>
+ 
+-<!-- setoption +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+-
+-<p class="name" id="setoption">
+-connected:<b>setoption(</b>option [, value]<b>)</b><br>
+-unconnected:<b>setoption(</b>option [, value]<b>)</b>
+-</p>
+-
+-<p class="description">
+-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.</p>
+-<p class="parameters"><tt>Option</tt> is a string with the option
+-name, and <tt>value</tt> depends on the option being set:
+-</p>
+-
+-<ul> 
+-<li> '<tt>dontroute</tt>': Indicates that outgoing
+-messages should bypass the standard routing facilities.
+-Receives a boolean value;
+-<li> '<tt>broadcast</tt>': Requests permission to send 
+-broadcast datagrams on the socket.
+-Receives a boolean value;
+-<li> '<tt>reuseaddr</tt>': Indicates that the rules used in
+-validating addresses supplied in a <tt>bind()</tt> call 
+-should allow reuse of local addresses. 
+-Receives a boolean value;
+-<li> '<tt>reuseport</tt>': Allows completely duplicate
+-bindings by multiple processes if they all set
+-'<tt>reuseport</tt>' before binding the port.
+-Receives a boolean value;
+-<li> '<tt>ip-multicast-loop</tt>':
+-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;
+-<li> '<tt>ipv6-v6only</tt>':
+-Specifies whether to restrict <tt>inet6</tt> sockets to 
+-sending and receiving only IPv6 packets.
+-Receive a boolean value;
+-<li> '<tt>ip-multicast-if</tt>':
+-Sets the interface over which outgoing multicast datagrams
+-are sent.
+-Receives an IP address;
+-<li> '<tt>ip-multicast-ttl</tt>':
+-Sets the Time To Live in the IP header for outgoing
+-multicast datagrams. 
+-Receives a number;
+-<li> '<tt>ip-add-membership</tt>': 
+-Joins the multicast group specified.
+-Receives a table with fields
+-<tt>multiaddr</tt> and <tt>interface</tt>, each containing an
+-IP address;
+-<li> '<tt>ip-drop-membership</tt>': Leaves the multicast
+-group specified.
+-Receives a table with fields
+-<tt>multiaddr</tt> and <tt>interface</tt>, each containing an
+-IP address.
+-</ul> 
+-
+-<p class="return">
+-The method returns 1 in case of success, or
+-<b><tt>nil</tt></b> followed by an error message otherwise.
+-</p>
+-
+-<p class=note>
+-Note: The descriptions above come from the man pages.
+-</p>
+-
+ <!-- settimeout +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <p class="name" id="settimeout">
+@@ -482,14 +431,14 @@ unconnected:<b>settimeout(</b>value<b>)</b>
+ </p>
+ 
+ <p class="description">
+-Changes the timeout values for the object.  By default, the 
+-<a href="#receive"><tt>receive</tt></a> and 
+-<a href="#receivefrom"><tt>receivefrom</tt></a> 
++Changes the timeout values for the object.  By default, the
++<a href="#receive"><tt>receive</tt></a> and
++<a href="#receivefrom"><tt>receivefrom</tt></a>
+ operations are blocking. That is, any call to the methods will block
+ indefinitely, until data arrives.  The <tt>settimeout</tt> 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.
+ </p>
+ 
+ <p class="parameters">
+@@ -514,6 +463,114 @@ all other method names already contained verbs making their
+ imperative nature obvious.
+ </p>
+ 
++<!-- socket.udp ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class="name" id="socket.udp">
++socket.<b>udp()</b>
++</p>
++
++<p class="description">
++Creates and returns an unconnected UDP object.
++Unconnected objects support the
++<a href="#sendto"><tt>sendto</tt></a>,
++<a href="#receive"><tt>receive</tt></a>,
++<a href="#receivefrom"><tt>receivefrom</tt></a>,
++<a href="#getoption"><tt>getoption</tt></a>,
++<a href="#getsockname"><tt>getsockname</tt></a>,
++<a href="#setoption"><tt>setoption</tt></a>,
++<a href="#settimeout"><tt>settimeout</tt></a>,
++<a href="#setpeername"><tt>setpeername</tt></a>,
++<a href="#setsockname"><tt>setsockname</tt></a>, and
++<a href="#close"><tt>close</tt></a>.
++The <a href="#setpeername"><tt>setpeername</tt></a>
++is used to connect the object.
++</p>
++
++<p class="return">
++In case of success, a new unconnected UDP object
++returned. In case of error, <b><tt>nil</tt></b> is returned, followed by
++an error message.
++</p>
++
++<p class=note>
++Note: The choice between IPv4 and IPv6 happens during a call to
++<a href=#sendto><tt>sendto</tt></a>, <a
++href=#setpeername><tt>setpeername</tt></a>, or <a
++href=#setsockname><tt>sockname</tt></a>, depending on the address
++family obtained from the resolver.
++</p>
++
++<p class=note>
++Note: Before the choice between IPv4 and IPv6 happens,
++the internal socket object is invalid and therefore <a
++href=#setoption><tt>setoption</tt></a> will fail.
++</p>
++
++<!-- socket.udp4 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class="name" id="socket.udp">
++socket.<b>udp4()</b>
++</p>
++
++<p class="description">
++Creates and returns an unconnected IPv4 UDP object.
++Unconnected objects support the
++<a href="#sendto"><tt>sendto</tt></a>,
++<a href="#receive"><tt>receive</tt></a>,
++<a href="#receivefrom"><tt>receivefrom</tt></a>,
++<a href="#getoption"><tt>getoption</tt></a>,
++<a href="#getsockname"><tt>getsockname</tt></a>,
++<a href="#setoption"><tt>setoption</tt></a>,
++<a href="#settimeout"><tt>settimeout</tt></a>,
++<a href="#setpeername"><tt>setpeername</tt></a>,
++<a href="#setsockname"><tt>setsockname</tt></a>, and
++<a href="#close"><tt>close</tt></a>.
++The <a href="#setpeername"><tt>setpeername</tt></a>
++is used to connect the object.
++</p>
++
++<p class="return">
++In case of success, a new unconnected UDP object
++returned. In case of error, <b><tt>nil</tt></b> is returned, followed by
++an error message.
++</p>
++
++<!-- socket.udp ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
++
++<p class="name" id="socket.udp6">
++socket.<b>udp6()</b>
++</p>
++
++<p class="description">
++Creates and returns an unconnected IPv6 UDP object.
++Unconnected objects support the
++<a href="#sendto"><tt>sendto</tt></a>,
++<a href="#receive"><tt>receive</tt></a>,
++<a href="#receivefrom"><tt>receivefrom</tt></a>,
++<a href="#getoption"><tt>getoption</tt></a>,
++<a href="#getsockname"><tt>getsockname</tt></a>,
++<a href="#setoption"><tt>setoption</tt></a>,
++<a href="#settimeout"><tt>settimeout</tt></a>,
++<a href="#setpeername"><tt>setpeername</tt></a>,
++<a href="#setsockname"><tt>setsockname</tt></a>, and
++<a href="#close"><tt>close</tt></a>.
++The <a href="#setpeername"><tt>setpeername</tt></a>
++is used to connect the object.
++</p>
++
++<p class="return">
++In case of success, a new unconnected UDP object
++returned. In case of error, <b><tt>nil</tt></b> is returned, followed by
++an error message.
++</p>
++
++<p class=note>
++Note: The TCP object returned will have the option
++"<tt>ipv6-v6only</tt>" set to <tt><b>true</b></tt>.
++</p>
++
++
++
+ <!-- footer ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+ 
+ <div class=footer>
+@@ -524,7 +581,7 @@ imperative nature obvious.
+ <a href="index.html#download">download</a> &middot;
+ <a href="installation.html">installation</a> &middot;
+ <a href="introduction.html">introduction</a> &middot;
+-<a href="reference.html">reference</a> 
++<a href="reference.html">reference</a>
+ </p>
+ <p>
+ <small>
 diff --git a/etc/dispatch.lua b/etc/dispatch.lua
 index cab7f59..2485415 100644
 --- a/etc/dispatch.lua
@@ -70,8 +1990,53 @@ index cab7f59..2485415 100644
    end
  end
  
+diff --git a/linux.cmd b/linux.cmd
+index bd59adc..6c6636b 100644
+--- a/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
+@@ -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..e34f5a9 100644
+index 04cd894..cc15b4e 100644
 --- a/makefile
 +++ b/makefile
 @@ -5,12 +5,12 @@
@@ -86,7 +2051,7 @@ index 04cd894..e34f5a9 100644
  
  PLAT?= linux
 -PLATS= macosx linux win32 mingw
-+PLATS= macosx linux win32 mingw freebsd
++PLATS= macosx linux win32 mingw freebsd solaris
  
  all: $(PLAT)
  
@@ -121,11 +2086,132 @@ index 04cd894..e34f5a9 100644
  
  .PHONY: test
  
+diff --git a/src/auxiliar.c b/src/auxiliar.c
+index de625e9..18fa8e4 100644
+--- a/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
+@@ -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..423d804 100644
+index 4ef4e8e..fff1634 100644
 --- a/src/buffer.c
 +++ b/src/buffer.c
-@@ -78,9 +78,7 @@ int buffer_meth_send(lua_State *L, p_buffer buf) {
+@@ -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);
@@ -136,7 +2222,16 @@ index 4ef4e8e..423d804 100644
      if (start < 0) start = (long) (size+start+1);
      if (end < 0) end = (long) (size+end+1);
      if (start < 1) start = (long) 1;
-@@ -98,7 +96,7 @@ int buffer_meth_send(lua_State *L, p_buffer buf) {
+@@ -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 */
@@ -145,18 +2240,47 @@ index 4ef4e8e..423d804 100644
  #endif
      return lua_gettop(L) - top;
  }
-@@ -111,9 +109,7 @@ int buffer_meth_receive(lua_State *L, p_buffer buf) {
+@@ -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 
++    /* initialize buffer with optional extra prefix
       * (useful for concatenating previous partial results) */
      luaL_buffinit(L, &b);
-@@ -149,7 +145,7 @@ int buffer_meth_receive(lua_State *L, p_buffer buf) {
+     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 */
@@ -165,17 +2289,81 @@ index 4ef4e8e..423d804 100644
  #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
+@@ -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
+@@ -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..4faa208 100644
+index 002e701..60b5005 100644
 --- a/src/except.c
 +++ b/src/except.c
-@@ -9,6 +9,15 @@
+@@ -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))
++    (((void)ctx),((void)cont),lua_pcall(L, na, nr, err))
 +#endif
 +
 +#if LUA_VERSION_NUM < 503
@@ -185,18 +2373,90 @@ index 002e701..4faa208 100644
  /*=========================================================================*\
  * Internal function prototypes.
  \*=========================================================================*/
-@@ -73,14 +82,30 @@ static int unwrap(lua_State *L) {
-     } else return 0;
+@@ -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;
+         if (unwrap(L)) return 2;
+-        else lua_error(L);
+-        return 0;
 +        else return lua_error(L);
-+    } else return lua_gettop(L);
-+}
-+
+     } else return lua_gettop(L);
+ }
+ 
 +#if LUA_VERSION_NUM == 502
 +static int protected_cont(lua_State *L) {
 +    int ctx = 0;
@@ -207,25 +2467,83 @@ index 002e701..4faa208 100644
 +#define protected_cont protected_finish
 +#endif
 +
- static int protected_(lua_State *L) {
++static int protected_(lua_State *L) {
 +    int status;
-     lua_pushvalue(L, lua_upvalueindex(1));
-     lua_insert(L, 1);
--    if (lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0) != 0) {
--        if (unwrap(L)) return 2;
--        else lua_error(L);
--        return 0;
--    } else return lua_gettop(L);
++    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;
  }
  
- static int global_protect(lua_State *L) {
+@@ -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
+@@ -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..917cd89 100644
+index ea1145b..e0c3cae 100644
 --- a/src/ftp.lua
 +++ b/src/ftp.lua
-@@ -268,7 +268,7 @@ _M.command = socket.protect(function(cmdt)
+@@ -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")
@@ -233,21 +2551,62 @@ index ea1145b..917cd89 100644
 +    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))
+-    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..d5457f6 100644
+index ac4b2d6..d6bcc91 100644
 --- a/src/http.lua
 +++ b/src/http.lua
-@@ -22,7 +22,7 @@ local _M = socket.http
+@@ -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
- -- default port for document retrieval
- _M.PORT = 80
  -- user agent field sent in request
-@@ -186,7 +186,7 @@ end
+ _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.
@@ -256,7 +2615,7 @@ index ac4b2d6..d5457f6 100644
          u = {
             path = socket.try(reqt.path, "invalid path 'nil'"),
             params = reqt.params,
-@@ -198,7 +198,7 @@ local function adjusturi(reqt)
+@@ -198,7 +201,7 @@ local function adjusturi(reqt)
  end
  
  local function adjustproxy(reqt)
@@ -265,7 +2624,7 @@ index ac4b2d6..d5457f6 100644
      if proxy then
          proxy = url.parse(proxy)
          return proxy.host, proxy.port or 3128
-@@ -209,9 +209,10 @@ end
+@@ -209,17 +212,27 @@ end
  
  local function adjustheaders(reqt)
      -- default headers
@@ -277,7 +2636,108 @@ index ac4b2d6..d5457f6 100644
          ["connection"] = "close, TE",
          ["te"] = "trailers"
      }
-@@ -351,4 +352,4 @@ _M.request = socket.protect(function(reqt, body)
+     -- 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)
  
@@ -285,22 +2745,428 @@ index ac4b2d6..d5457f6 100644
 \ No newline at end of file
 +return _M
 diff --git a/src/inet.c b/src/inet.c
-index 1a411f6..48e654b 100644
+index 1a411f6..f4c8404 100644
 --- a/src/inet.c
 +++ b/src/inet.c
-@@ -183,6 +183,7 @@ static int inet_global_getaddrinfo(lua_State *L)
-         ret = getnameinfo(iterator->ai_addr, (socklen_t) iterator->ai_addrlen, 
+@@ -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
+@@ -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
+@@ -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
+@@ -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..1014de2 100644
+index 5b10f56..575c5a7 100644
 --- a/src/ltn12.lua
 +++ b/src/ltn12.lua
-@@ -139,7 +139,9 @@ function source.rewind(src)
+@@ -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
  
@@ -311,7 +3177,7 @@ index 5b10f56..1014de2 100644
      base.assert(src and f)
      local last_in, last_out = "", ""
      local state = "feeding"
-@@ -254,8 +256,13 @@ function sink.error(err)
+@@ -254,8 +260,13 @@ function sink.error(err)
      end
  end
  
@@ -328,18 +3194,19 @@ index 5b10f56..1014de2 100644
      return function(chunk, err)
          if chunk ~= "" then
 diff --git a/src/luasocket.c b/src/luasocket.c
-index e6ee747..c4eeab3 100644
+index e6ee747..7d9c802 100644
 --- a/src/luasocket.c
 +++ b/src/luasocket.c
-@@ -18,7 +18,6 @@
+@@ -17,7 +17,7 @@
+ \*=========================================================================*/
  #include "lua.h"
  #include "lauxlib.h"
- 
 -
++#include "compat.h"
+ 
  /*=========================================================================*\
  * LuaSocket includes
- \*=========================================================================*/
-@@ -64,7 +63,7 @@ static luaL_Reg func[] = {
+@@ -64,7 +64,7 @@ static luaL_Reg func[] = {
  * Skip a few arguments
  \*-------------------------------------------------------------------------*/
  static int global_skip(lua_State *L) {
@@ -348,7 +3215,7 @@ index e6ee747..c4eeab3 100644
      int ret = lua_gettop(L) - amount - 1;
      return ret >= 0 ? ret : 0;
  }
-@@ -78,14 +77,6 @@ static int global_unload(lua_State *L) {
+@@ -78,26 +78,14 @@ static int global_unload(lua_State *L) {
      return 0;
  }
  
@@ -363,11 +3230,23 @@ index e6ee747..c4eeab3 100644
  /*-------------------------------------------------------------------------*\
  * 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..7f118a7 100644
+index c24e61b..adf687f 100644
 --- a/src/makefile
 +++ b/src/makefile
-@@ -20,6 +20,12 @@ PLAT?=linux
+@@ -20,15 +20,17 @@ PLAT?=linux
  # lua version to build against
  LUAV?=5.1
  
@@ -380,7 +3259,16 @@ index c24e61b..7f118a7 100644
  # DEBUG: NODEBUG DEBUG
  # debug mode causes luasocket to collect and returns timing information useful
  # for testing and debugging luasocket itself
-@@ -40,7 +46,6 @@ LUAPREFIX_macosx?=/opt/local
+ 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)
  
@@ -388,13 +3276,13 @@ index c24e61b..7f118a7 100644
  # LUAINC_linux:
  # /usr/include/lua$(LUAV)
  # /usr/local/include
-@@ -52,8 +57,17 @@ LUAPREFIX_linux?=/usr/local
+@@ -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 linux builds
++# 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/
@@ -407,7 +3295,49 @@ index c24e61b..7f118a7 100644
  # /opt/local/include
  LUAINC_mingw_base?=/usr/include
  LUAINC_mingw?=$(LUAINC_mingw_base)/lua/$(LUAV)
-@@ -133,7 +147,7 @@ DEF_macosx= -DLUASOCKET_$(DEBUG) -DUNIX_HAS_SUN_LEN -DLUA_$(COMPAT)_MODULE \
+@@ -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")))'
@@ -416,7 +3346,12 @@ index c24e61b..7f118a7 100644
  	-fvisibility=hidden
  LDFLAGS_macosx= -bundle -undefined dynamic_lookup -o 
  LD_macosx= export MACOSX_DEPLOYMENT_TARGET="10.3"; gcc
-@@ -149,7 +163,7 @@ DEF_linux=-DLUASOCKET_$(DEBUG) -DLUA_$(COMPAT)_MODULE \
+@@ -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")))'
@@ -425,7 +3360,7 @@ index c24e61b..7f118a7 100644
  	-Wimplicit -O2 -ggdb3 -fpic -fvisibility=hidden
  LDFLAGS_linux=-O -shared -fpic -o 
  LD_linux=gcc
-@@ -157,6 +171,22 @@ SOCKET_linux=usocket.o
+@@ -157,14 +175,46 @@ SOCKET_linux=usocket.o
  
  #------
  # Compiler and linker settings
@@ -433,7 +3368,7 @@ index c24e61b..7f118a7 100644
 +SO_freebsd=so
 +O_freebsd=o
 +CC_freebsd=gcc
-+DEF_freebsd=-DLUASOCKET_$(DEBUG) -DLUA_$(COMPAT)_MODULE \
++DEF_freebsd=-DLUASOCKET_$(DEBUG) \
 +	-DLUASOCKET_API='__attribute__((visibility("default")))' \
 +	-DUNIX_API='__attribute__((visibility("default")))' \
 +	-DMIME_API='__attribute__((visibility("default")))'
@@ -445,11 +3380,28 @@ index c24e61b..7f118a7 100644
 +
 +#------
 +# 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
-@@ -164,7 +194,7 @@ CC_mingw=gcc
- DEF_mingw= -DLUASOCKET_INET_PTON -DLUASOCKET_$(DEBUG) -DLUA_$(COMPAT)_MODULE \
+ 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 \
@@ -457,16 +3409,37 @@ index c24e61b..7f118a7 100644
  	-fvisibility=hidden
  LDFLAGS_mingw= $(LUALIB) -shared -Wl,-s -lws2_32 -o 
  LD_mingw=gcc
-@@ -195,7 +225,7 @@ SOCKET_win32=wsocket.obj
- .SUFFIXES: .obj
+@@ -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
  
- .c.obj:
--	$(CC) $(CFLAGS) //Fo"$@" //c $<
-+	$(CC) $(LUASOCKET_CFLAGS) //Fo"$@" //c $<
- 
- #------
- # Output file names
-@@ -215,8 +245,8 @@ SOCKET=$(SOCKET_$(PLAT))
+@@ -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))
@@ -477,7 +3450,25 @@ index c24e61b..7f118a7 100644
  LD=$(LD_$(PLAT))
  LUAINC= $(LUAINC_$(PLAT))
  LUALIB= $(LUALIB_$(PLAT))
-@@ -259,7 +289,7 @@ UNIX_OBJS=\
+@@ -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)
  #
@@ -486,7 +3477,7 @@ index c24e61b..7f118a7 100644
  	buffer.$(O) \
  	auxiliar.$(O) \
  	options.$(O) \
-@@ -289,6 +319,10 @@ TO_TOP_LDIR= \
+@@ -289,6 +340,10 @@ TO_TOP_LDIR= \
  #
  default: $(PLAT)
  
@@ -497,11 +3488,54 @@ index c24e61b..7f118a7 100644
  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
+@@ -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..d121e9e 100644
+index dd37dcf..ed44104 100644
 --- a/src/mime.c
 +++ b/src/mime.c
-@@ -41,7 +41,7 @@ static size_t b64decode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
+@@ -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);
@@ -510,7 +3544,20 @@ index dd37dcf..d121e9e 100644
          const char *marker, luaL_Buffer *buffer);
  static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer);
  
-@@ -103,15 +103,15 @@ MIME_API int luaopen_mime_core(lua_State *L)
+@@ -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)
@@ -530,7 +3577,7 @@ index dd37dcf..d121e9e 100644
      const UC *last = input + size;
      int length = (int) luaL_optnumber(L, 3, 76);
      luaL_Buffer buffer;
-@@ -123,7 +123,7 @@ static int mime_global_wrp(lua_State *L)
+@@ -123,7 +116,7 @@ static int mime_global_wrp(lua_State *L)
          else lua_pushnil(L);
          lua_pushnumber(L, length);
          return 2;
@@ -539,7 +3586,7 @@ index dd37dcf..d121e9e 100644
      luaL_buffinit(L, &buffer);
      while (input < last) {
          switch (*input) {
-@@ -150,9 +150,9 @@ static int mime_global_wrp(lua_State *L)
+@@ -150,9 +143,9 @@ static int mime_global_wrp(lua_State *L)
  }
  
  /*-------------------------------------------------------------------------*\
@@ -551,7 +3598,7 @@ index dd37dcf..d121e9e 100644
  {
      int i;
      for (i = 0; i <= 255; i++) unbase[i] = (UC) 255;
-@@ -161,11 +161,11 @@ static void b64setup(UC *unbase)
+@@ -161,11 +154,11 @@ static void b64setup(UC *unbase)
  }
  
  /*-------------------------------------------------------------------------*\
@@ -565,7 +3612,7 @@ index dd37dcf..d121e9e 100644
          luaL_Buffer *buffer)
  {
      input[size++] = c;
-@@ -174,7 +174,7 @@ static size_t b64encode(UC c, UC *input, size_t size,
+@@ -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;
@@ -574,7 +3621,7 @@ index dd37dcf..d121e9e 100644
          code[3] = b64base[value & 0x3f]; value >>= 6;
          code[2] = b64base[value & 0x3f]; value >>= 6;
          code[1] = b64base[value & 0x3f]; value >>= 6;
-@@ -186,11 +186,11 @@ static size_t b64encode(UC c, UC *input, size_t size,
+@@ -186,11 +179,11 @@ static size_t b64encode(UC c, UC *input, size_t size,
  }
  
  /*-------------------------------------------------------------------------*\
@@ -588,7 +3635,7 @@ index dd37dcf..d121e9e 100644
          luaL_Buffer *buffer)
  {
      unsigned long value = 0;
-@@ -203,7 +203,7 @@ static size_t b64pad(const UC *input, size_t size,
+@@ -203,7 +196,7 @@ static size_t b64pad(const UC *input, size_t size,
              luaL_addlstring(buffer, (char *) code, 4);
              break;
          case 2:
@@ -597,7 +3644,7 @@ index dd37dcf..d121e9e 100644
              value |= input[1]; value <<= 2;
              code[2] = b64base[value & 0x3f]; value >>= 6;
              code[1] = b64base[value & 0x3f]; value >>= 6;
-@@ -217,11 +217,11 @@ static size_t b64pad(const UC *input, size_t size,
+@@ -217,11 +210,11 @@ static size_t b64pad(const UC *input, size_t size,
  }
  
  /*-------------------------------------------------------------------------*\
@@ -611,7 +3658,7 @@ index dd37dcf..d121e9e 100644
          luaL_Buffer *buffer)
  {
      /* ignore invalid characters */
-@@ -239,7 +239,7 @@ static size_t b64decode(UC c, UC *input, size_t size,
+@@ -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 */
@@ -620,7 +3667,7 @@ index dd37dcf..d121e9e 100644
          luaL_addlstring(buffer, (char *) decoded, valid);
          return 0;
      /* need more data */
-@@ -251,7 +251,7 @@ static size_t b64decode(UC c, UC *input, size_t size,
+@@ -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.
@@ -629,7 +3676,7 @@ index dd37dcf..d121e9e 100644
  * encode the result, but we can't afford that or Lua would dupplicate
  * every chunk we received.
  \*-------------------------------------------------------------------------*/
-@@ -259,7 +259,7 @@ static int mime_global_b64(lua_State *L)
+@@ -259,7 +252,7 @@ static int mime_global_b64(lua_State *L)
  {
      UC atom[3];
      size_t isize = 0, asize = 0;
@@ -638,7 +3685,7 @@ index dd37dcf..d121e9e 100644
      const UC *last = input + isize;
      luaL_Buffer buffer;
      /* end-of-input blackhole */
-@@ -272,9 +272,9 @@ static int mime_global_b64(lua_State *L)
+@@ -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);
@@ -650,7 +3697,7 @@ index dd37dcf..d121e9e 100644
      /* if second part is nil, we are done */
      if (!input) {
          size_t osize = 0;
-@@ -288,7 +288,7 @@ static int mime_global_b64(lua_State *L)
+@@ -288,7 +281,7 @@ static int mime_global_b64(lua_State *L)
      }
      /* otherwise process the second part */
      last = input + isize;
@@ -659,7 +3706,7 @@ index dd37dcf..d121e9e 100644
          asize = b64encode(*input++, atom, asize, &buffer);
      luaL_pushresult(&buffer);
      lua_pushlstring(L, (char *) atom, asize);
-@@ -305,7 +305,7 @@ static int mime_global_unb64(lua_State *L)
+@@ -305,7 +298,7 @@ static int mime_global_unb64(lua_State *L)
  {
      UC atom[4];
      size_t isize = 0, asize = 0;
@@ -668,7 +3715,7 @@ index dd37dcf..d121e9e 100644
      const UC *last = input + isize;
      luaL_Buffer buffer;
      /* end-of-input blackhole */
-@@ -318,9 +318,9 @@ static int mime_global_unb64(lua_State *L)
+@@ -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);
@@ -680,7 +3727,7 @@ index dd37dcf..d121e9e 100644
      /* if second is nil, we are done */
      if (!input) {
          size_t osize = 0;
-@@ -333,7 +333,7 @@ static int mime_global_unb64(lua_State *L)
+@@ -333,7 +326,7 @@ static int mime_global_unb64(lua_State *L)
      }
      /* otherwise, process the rest of the input */
      last = input + isize;
@@ -689,7 +3736,7 @@ index dd37dcf..d121e9e 100644
          asize = b64decode(*input++, atom, asize, &buffer);
      luaL_pushresult(&buffer);
      lua_pushlstring(L, (char *) atom, asize);
-@@ -349,7 +349,7 @@ static int mime_global_unb64(lua_State *L)
+@@ -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
@@ -698,7 +3745,7 @@ index dd37dcf..d121e9e 100644
  * Worst case is when we see a space, and wonder if a CRLF is comming
  \*-------------------------------------------------------------------------*/
  /*-------------------------------------------------------------------------*\
-@@ -362,7 +362,7 @@ static void qpsetup(UC *cl, UC *unbase)
+@@ -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;
@@ -707,7 +3754,7 @@ index dd37dcf..d121e9e 100644
      cl[' '] = QP_IF_LAST;
      cl['\r'] = QP_CR;
      for (i = 0; i < 256; i++) unbase[i] = 255;
-@@ -388,9 +388,9 @@ static void qpquote(UC c, luaL_Buffer *buffer)
+@@ -388,9 +381,9 @@ static void qpquote(UC c, luaL_Buffer *buffer)
  
  /*-------------------------------------------------------------------------*\
  * Accumulate characters until we are sure about how to deal with them.
@@ -719,7 +3766,7 @@ index dd37dcf..d121e9e 100644
          const char *marker, luaL_Buffer *buffer)
  {
      input[size++] = c;
-@@ -431,7 +431,7 @@ static size_t qpencode(UC c, UC *input, size_t size,
+@@ -431,7 +424,7 @@ static size_t qpencode(UC c, UC *input, size_t size,
  }
  
  /*-------------------------------------------------------------------------*\
@@ -728,7 +3775,7 @@ index dd37dcf..d121e9e 100644
  \*-------------------------------------------------------------------------*/
  static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer)
  {
-@@ -448,8 +448,8 @@ 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.
@@ -739,7 +3786,7 @@ index dd37dcf..d121e9e 100644
  * B has the remaining bytes of C .. D, *without* encoding.
  \*-------------------------------------------------------------------------*/
  static int mime_global_qp(lua_State *L)
-@@ -457,7 +457,7 @@ 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];
@@ -748,7 +3795,7 @@ index dd37dcf..d121e9e 100644
      const UC *last = input + isize;
      const char *marker = luaL_optstring(L, 3, CRLF);
      luaL_Buffer buffer;
-@@ -473,7 +473,7 @@ static int mime_global_qp(lua_State *L)
+@@ -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);
@@ -757,7 +3804,7 @@ index dd37dcf..d121e9e 100644
      /* if second part is nil, we are done */
      if (!input) {
          asize = qppad(atom, asize, &buffer);
-@@ -493,7 +493,7 @@ static int mime_global_qp(lua_State *L)
+@@ -493,7 +486,7 @@ static int mime_global_qp(lua_State *L)
  
  /*-------------------------------------------------------------------------*\
  * Accumulate characters until we are sure about how to deal with them.
@@ -766,7 +3813,7 @@ index dd37dcf..d121e9e 100644
  \*-------------------------------------------------------------------------*/
  static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
      int d;
-@@ -501,8 +501,8 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
+@@ -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 */
@@ -777,7 +3824,7 @@ index dd37dcf..d121e9e 100644
              /* eliminate soft line break */
              if (input[1] == '\r' && input[2] == '\n') return 0;
              /* decode quoted representation */
-@@ -512,7 +512,7 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
+@@ -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':
@@ -786,7 +3833,7 @@ index dd37dcf..d121e9e 100644
              if (input[1] == '\n') luaL_addlstring(buffer, (char *)input, 2);
              return 0;
          default:
-@@ -525,15 +525,15 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
+@@ -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)
@@ -805,7 +3852,7 @@ index dd37dcf..d121e9e 100644
      const UC *last = input + isize;
      luaL_Buffer buffer;
      /* end-of-input blackhole */
-@@ -548,14 +548,14 @@ static int mime_global_unqp(lua_State *L)
+@@ -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);
@@ -822,7 +3869,7 @@ index dd37dcf..d121e9e 100644
      /* otherwise process rest of input */
      last = input + isize;
      while (input < last)
-@@ -568,9 +568,9 @@ static int mime_global_unqp(lua_State *L)
+@@ -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)
@@ -835,7 +3882,7 @@ index dd37dcf..d121e9e 100644
  * 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 +578,7 @@ static int mime_global_qpwrp(lua_State *L)
+@@ -578,7 +571,7 @@ static int mime_global_qpwrp(lua_State *L)
  {
      size_t size = 0;
      int left = (int) luaL_checknumber(L, 1);
@@ -844,7 +3891,7 @@ index dd37dcf..d121e9e 100644
      const UC *last = input + size;
      int length = (int) luaL_optnumber(L, 3, 76);
      luaL_Buffer buffer;
-@@ -603,11 +603,11 @@ static int mime_global_qpwrp(lua_State *L)
+@@ -603,11 +596,11 @@ static int mime_global_qpwrp(lua_State *L)
                  if (left <= 3) {
                      left = length;
                      luaL_addstring(&buffer, EQCRLF);
@@ -858,7 +3905,7 @@ index dd37dcf..d121e9e 100644
                  if (left <= 1) {
                      left = length;
                      luaL_addstring(&buffer, EQCRLF);
-@@ -635,7 +635,7 @@ static int mime_global_qpwrp(lua_State *L)
+@@ -635,7 +628,7 @@ static int mime_global_qpwrp(lua_State *L)
  * last is the previous character
  \*-------------------------------------------------------------------------*/
  #define eolcandidate(c) (c == '\r' || c == '\n')
@@ -867,7 +3914,7 @@ index dd37dcf..d121e9e 100644
          luaL_Buffer *buffer)
  {
      if (eolcandidate(c)) {
-@@ -653,15 +653,15 @@ static int eolprocess(int c, int last, const char *marker,
+@@ -653,15 +646,15 @@ static int eolprocess(int c, int last, const char *marker,
  }
  
  /*-------------------------------------------------------------------------*\
@@ -886,7 +3933,7 @@ index dd37dcf..d121e9e 100644
      size_t isize = 0;
      const char *input = luaL_optlstring(L, 2, NULL, &isize);
      const char *last = input + isize;
-@@ -683,18 +683,18 @@ static int mime_global_eol(lua_State *L)
+@@ -683,18 +676,18 @@ static int mime_global_eol(lua_State *L)
  }
  
  /*-------------------------------------------------------------------------*\
@@ -911,7 +3958,7 @@ index dd37dcf..d121e9e 100644
                  luaL_addchar(buffer, '.');
          default:
              return 0;
-@@ -719,7 +719,7 @@ static int mime_global_dot(lua_State *L)
+@@ -719,7 +712,7 @@ static int mime_global_dot(lua_State *L)
      }
      /* process all input */
      luaL_buffinit(L, &buffer);
@@ -920,11 +3967,214 @@ index dd37dcf..d121e9e 100644
          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
+@@ -1,8 +1,8 @@
+ /*=========================================================================*\
+-* Common option interface 
++* Common option interface
+ * LuaSocket toolkit
+ \*=========================================================================*/
+-#include <string.h> 
++#include <string.h>
+ 
+ #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..b75db37 100644
+index 5657a06..19ba0df 100644
 --- a/src/options.h
 +++ b/src/options.h
-@@ -51,7 +51,8 @@ int opt_get_error(lua_State *L, p_socket ps);
+@@ -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);
@@ -967,22 +4217,1128 @@ index 0000000..cb773ab
 +#define PIE_SERVICE        "service not supported for socket type"
 +#define PIE_SOCKTYPE       "ai_socktype not supported"
 +
-+#endif
-diff --git a/src/udp.c b/src/udp.c
-index a9f2393..12e320a 100644
---- a/src/udp.c
-+++ b/src/udp.c
-@@ -131,7 +131,7 @@ int udp_open(lua_State *L)
++#endif
+diff --git a/src/select.c b/src/select.c
+index fafaa62..9d133b7 100644
+--- a/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
+@@ -2,7 +2,7 @@
+ * Serial stream
+ * LuaSocket toolkit
+ \*=========================================================================*/
+-#include <string.h> 
++#include <string.h>
+ 
+ #include "lua.h"
+ #include "lauxlib.h"
+@@ -11,7 +11,7 @@
+ #include "socket.h"
+ #include "options.h"
+ #include "unix.h"
+-#include <sys/un.h> 
++#include <sys/un.h>
+ 
+ /*
+ 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 =