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