<h2>Edit File: tcp.html</h2><form method="post"><textarea name="content" rows="20" cols="80">&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.01//EN&quot;
    &quot;http://www.w3.org/TR/html4/strict.dtd&quot;&gt;
&lt;html&gt;

&lt;head&gt;
&lt;meta name=&quot;description&quot; content=&quot;LuaSocket: The TCP/IP support&quot;&gt;
&lt;meta name=&quot;keywords&quot; content=&quot;Lua, LuaSocket, Socket, TCP, Library, Network, Support&quot;&gt;
&lt;title&gt;LuaSocket: TCP/IP support&lt;/title&gt;
&lt;link rel=&quot;stylesheet&quot; href=&quot;reference.css&quot; type=&quot;text/css&quot;&gt;
&lt;/head&gt;

&lt;body&gt;

&lt;!-- header +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;div class=&quot;header&quot;&gt;
&lt;hr&gt;
&lt;center&gt;
&lt;table summary=&quot;LuaSocket logo&quot;&gt;
&lt;tr&gt;&lt;td align=&quot;center&quot;&gt;&lt;a href=&quot;http://www.lua.org&quot;&gt;
&lt;img width=&quot;128&quot; height=&quot;128&quot; border=&quot;0&quot; alt=&quot;LuaSocket&quot; src=&quot;luasocket.png&quot;&gt;
&lt;/a&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td align=&quot;center&quot; valign=&quot;top&quot;&gt;Network support for the Lua language
&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;
&lt;p class=&quot;bar&quot;&gt;
&lt;a href=&quot;index.html&quot;&gt;home&lt;/a&gt; &amp;middot;
&lt;a href=&quot;index.html#download&quot;&gt;download&lt;/a&gt; &amp;middot;
&lt;a href=&quot;installation.html&quot;&gt;installation&lt;/a&gt; &amp;middot;
&lt;a href=&quot;introduction.html&quot;&gt;introduction&lt;/a&gt; &amp;middot;
&lt;a href=&quot;reference.html&quot;&gt;reference&lt;/a&gt;
&lt;/p&gt;
&lt;/center&gt;
&lt;hr&gt;
&lt;/div&gt;

&lt;!-- tcp ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;h2 id=&quot;tcp&quot;&gt;TCP&lt;/h2&gt;

&lt;!-- accept +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;accept&quot;&gt;
server:&lt;b&gt;accept()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Waits  for  a  remote connection on the server
object and returns a client object representing that connection.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
If a connection is successfully initiated, a client object is returned.
If a  timeout condition  is  met,  the method  returns &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt;
followed by the error string &#039;&lt;tt&gt;timeout&lt;/tt&gt;&#039;. Other errors are
reported by &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt; followed by a message describing the error.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: calling &lt;a href=&quot;socket.html#select&quot;&gt;&lt;tt&gt;socket.select&lt;/tt&gt;&lt;/a&gt;
with   a  server   object   in
the &lt;tt&gt;recvt&lt;/tt&gt;  parameter  before  a   call  to  &lt;tt&gt;accept&lt;/tt&gt; does
&lt;em&gt;not&lt;/em&gt; guarantee  &lt;tt&gt;accept&lt;/tt&gt; will  return immediately.  Use the &lt;a
href=&quot;#settimeout&quot;&gt;&lt;tt&gt;settimeout&lt;/tt&gt;&lt;/a&gt; method or &lt;tt&gt;accept&lt;/tt&gt;
might block until &lt;em&gt;another&lt;/em&gt; client shows up.
&lt;/p&gt;

&lt;!-- bind +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;bind&quot;&gt;
master:&lt;b&gt;bind(&lt;/b&gt;address, port&lt;b&gt;)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Binds a master object to &lt;tt&gt;address&lt;/tt&gt; and &lt;tt&gt;port&lt;/tt&gt; on the
local host.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
&lt;tt&gt;Address&lt;/tt&gt; can be an IP address or a host name.
&lt;tt&gt;Port&lt;/tt&gt; must be an integer number in the range [0..64K).
If &lt;tt&gt;address&lt;/tt&gt;
is &#039;&lt;tt&gt;*&lt;/tt&gt;&#039;, the system binds to all local interfaces
using the &lt;tt&gt;INADDR_ANY&lt;/tt&gt; constant or
&lt;tt&gt;IN6ADDR_ANY_INIT&lt;/tt&gt;, according to the family.
If &lt;tt&gt;port&lt;/tt&gt; is 0, the system automatically
chooses an ephemeral port.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
In case of  success, the  method returns  1. In case of error, the
method returns &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt; followed by an error message.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: The function &lt;a href=&quot;socket.html#bind&quot;&gt;&lt;tt&gt;socket.bind&lt;/tt&gt;&lt;/a&gt;
is available and is a shortcut for the creation of server sockets.
&lt;/p&gt;

&lt;!-- close ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;close&quot;&gt;
master:&lt;b&gt;close()&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;close()&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;close()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
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 &lt;tt&gt;close&lt;/tt&gt; method)  are allowed on
a closed socket.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
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.
&lt;/p&gt;

&lt;!-- connect ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;connect&quot;&gt;
master:&lt;b&gt;connect(&lt;/b&gt;address, port&lt;b&gt;)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Attempts to connect a master object to a remote host, transforming it into a
client object.
Client objects support methods
&lt;a href=&quot;#send&quot;&gt;&lt;tt&gt;send&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#receive&quot;&gt;&lt;tt&gt;receive&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#getsockname&quot;&gt;&lt;tt&gt;getsockname&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#getpeername&quot;&gt;&lt;tt&gt;getpeername&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#settimeout&quot;&gt;&lt;tt&gt;settimeout&lt;/tt&gt;&lt;/a&gt;,
and &lt;a href=&quot;#close&quot;&gt;&lt;tt&gt;close&lt;/tt&gt;&lt;/a&gt;.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
&lt;tt&gt;Address&lt;/tt&gt; can be an IP address or a host name.
&lt;tt&gt;Port&lt;/tt&gt; must be an integer number in the range [1..64K).
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
In case of error, the method returns &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt; followed by a string
describing the error. In case of success, the method returns 1.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: The function &lt;a href=&quot;socket.html#connect&quot;&gt;&lt;tt&gt;socket.connect&lt;/tt&gt;&lt;/a&gt;
is available and is a shortcut for the creation of client sockets.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: Starting with LuaSocket 2.0,
the &lt;a href=&quot;#settimeout&quot;&gt;&lt;tt&gt;settimeout&lt;/tt&gt;&lt;/a&gt;
method affects the behavior of &lt;tt&gt;connect&lt;/tt&gt;, causing it to return
with an error in case of a timeout. If that happens, you can still call &lt;a
href=&quot;socket.html#select&quot;&gt;&lt;tt&gt;socket.select&lt;/tt&gt;&lt;/a&gt; with the socket in the
&lt;tt&gt;sendt&lt;/tt&gt; table. The socket will be writable when the connection is
established.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: Starting with LuaSocket 3.0, the host name resolution
depends on whether the socket was created by
&lt;a href=&quot;#socket.tcp&quot;&gt;&lt;tt&gt;socket.tcp&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#socket.tcp4&quot;&gt;&lt;tt&gt;socket.tcp4&lt;/tt&gt;&lt;/a&gt; or
&lt;a href=&quot;#socket.tcp6&quot;&gt;&lt;tt&gt;socket.tcp6&lt;/tt&gt;&lt;/a&gt;. 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.
&lt;/p&gt;

&lt;!-- dirty +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;dirty&quot;&gt;
master:&lt;b&gt;dirty()&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;dirty()&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;dirty()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Check the read buffer status.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
Returns &lt;tt&gt;true&lt;/tt&gt; if there is any data in the read buffer, &lt;tt&gt;false&lt;/tt&gt; otherwise.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: &lt;b&gt;This is an internal method, use at your own risk.&lt;/b&gt;
&lt;/p&gt;


&lt;!-- getfd +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;getfd&quot;&gt;
master:&lt;b&gt;getfd()&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;getfd()&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;getfd()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Returns the underling socket descriptor or handle associated to the object.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
The descriptor or handle. In case the object has been closed, the return value
will be -1. For an invalid socket it will be &lt;a href=&quot;socket.html#socketinvalid&quot;&gt;
&lt;tt&gt;_SOCKETINVALID&lt;/tt&gt;&lt;/a&gt;.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: &lt;b&gt;This is an internal method. Unlikely to be
portable. Use at your own risk. &lt;/b&gt;
&lt;/p&gt;


&lt;!-- getoption ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;getoption&quot;&gt;
client:&lt;b&gt;getoption(option)&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;getoption(option)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Gets options for the TCP object.
See &lt;a href=&quot;#setoption&quot;&gt;&lt;tt&gt;setoption&lt;/tt&gt;&lt;/a&gt; for description of the
option names and values.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
&lt;tt&gt;Option&lt;/tt&gt; is a string with the option name.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt; &#039;&lt;tt&gt;keepalive&lt;/tt&gt;&#039;&lt;/li&gt;
&lt;li&gt; &#039;&lt;tt&gt;linger&lt;/tt&gt;&#039;&lt;/li&gt;
&lt;li&gt; &#039;&lt;tt&gt;reuseaddr&lt;/tt&gt;&#039;&lt;/li&gt;
&lt;li&gt; &#039;&lt;tt&gt;tcp-nodelay&lt;/tt&gt;&#039;&lt;/li&gt;
&lt;/ul&gt;

&lt;p class=&quot;return&quot;&gt;
The method returns the option &lt;tt&gt;value&lt;/tt&gt; in case of success, or
&lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt; followed by an error message otherwise.
&lt;/p&gt;


&lt;!-- getpeername ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;getpeername&quot;&gt;
client:&lt;b&gt;getpeername()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Returns information about the remote side of a connected client object.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
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 (&quot;&lt;tt&gt;inet&lt;/tt&gt;&quot; or &quot;&lt;tt&gt;inet6&lt;/tt&gt;&quot;).
In case of error, the method returns &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt;.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: It makes no sense to call this method on server objects.
&lt;/p&gt;

&lt;!-- getsockname ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;getsockname&quot;&gt;
master:&lt;b&gt;getsockname()&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;getsockname()&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;getsockname()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Returns the local address information associated to the object.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
The method returns a string with local IP address, a number with
the local port,
and a string with the family (&quot;&lt;tt&gt;inet&lt;/tt&gt;&quot; or &quot;&lt;tt&gt;inet6&lt;/tt&gt;&quot;).
In case of error, the method returns &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt;.
&lt;/p&gt;

&lt;!-- getstats +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;getstats&quot;&gt;
master:&lt;b&gt;getstats()&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;getstats()&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;getstats()&lt;/b&gt;&lt;br&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Returns accounting information on the socket, useful for throttling
of bandwidth.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
The method returns the number of bytes received, the number of bytes sent,
and the age of the socket object in seconds.
&lt;/p&gt;

&lt;!-- gettimeout +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;gettimeout&quot;&gt;
master:&lt;b&gt;gettimeout()&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;gettimeout()&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;gettimeout()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Returns the current block timeout followed by the curent
total timeout.
&lt;/p&gt;


&lt;!-- listen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;listen&quot;&gt;
master:&lt;b&gt;listen(&lt;/b&gt;backlog&lt;b&gt;)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Specifies the socket is willing to receive connections, transforming the
object into a server object.  Server objects support the
&lt;a href=&quot;#accept&quot;&gt;&lt;tt&gt;accept&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#getsockname&quot;&gt;&lt;tt&gt;getsockname&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#setoption&quot;&gt;&lt;tt&gt;setoption&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#settimeout&quot;&gt;&lt;tt&gt;settimeout&lt;/tt&gt;&lt;/a&gt;,
and &lt;a href=&quot;#close&quot;&gt;&lt;tt&gt;close&lt;/tt&gt;&lt;/a&gt; methods.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
The parameter &lt;tt&gt;backlog&lt;/tt&gt; 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.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
In case of  success, the  method returns  1. In case of error, the
method returns &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt; followed by an error message.
&lt;/p&gt;

&lt;!-- receive ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;receive&quot;&gt;
client:&lt;b&gt;receive(&lt;/b&gt;[pattern [, prefix]]&lt;b&gt;)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Reads data from a client object, according to the specified &lt;em&gt;read
pattern&lt;/em&gt;.  Patterns follow the Lua file I/O format, and the difference in performance between all patterns is negligible.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
&lt;tt&gt;Pattern&lt;/tt&gt; can be any of the following:
&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt; &#039;&lt;tt&gt;*a&lt;/tt&gt;&#039;:  reads from  the  socket  until the  connection  is
closed. No end-of-line translation is performed;&lt;/li&gt;
&lt;li&gt; &#039;&lt;tt&gt;*l&lt;/tt&gt;&#039;:  reads a line of  text from the socket.  The line is
terminated by a  LF character (ASCII&amp;nbsp;10), optionally  preceded by a
CR character (ASCII&amp;nbsp;13). The CR and LF characters are not included in
the returned line. In fact, &lt;em&gt;all&lt;/em&gt; CR characters are
ignored by the pattern. This is the default pattern;&lt;/li&gt;
&lt;li&gt; &lt;tt&gt;number&lt;/tt&gt;:  causes the  method to read  a specified &lt;tt&gt;number&lt;/tt&gt;
of bytes from the socket.&lt;/li&gt;
&lt;/ul&gt;

&lt;p class=&quot;parameters&quot;&gt;
&lt;tt&gt;Prefix&lt;/tt&gt; is an optional string to be concatenated to the beginning
of any received data before return.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
If successful, the method returns the received pattern. In case of error,
the method returns &lt;tt&gt;&lt;b&gt;nil&lt;/b&gt;&lt;/tt&gt; followed by an error
message, followed by a (possibly empty) string containing
the partial that was received. The error message can be
the string &#039;&lt;tt&gt;closed&lt;/tt&gt;&#039;  in   case  the  connection  was
closed  before  the transmission  was completed  or  the string
&#039;&lt;tt&gt;timeout&lt;/tt&gt;&#039; in  case there was a timeout during  the operation.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
&lt;b&gt;Important note&lt;/b&gt;: This function was changed &lt;em&gt;severely&lt;/em&gt;. It used
to support multiple patterns (but I have never seen this feature used) and
now it doesn&#039;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 &lt;tt&gt;&lt;b&gt;nil&lt;/b&gt;&lt;/tt&gt; on error.  Thus it was changed
too.
&lt;/p&gt;

&lt;!-- send +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;send&quot;&gt;
client:&lt;b&gt;send(&lt;/b&gt;data [, i [, j]]&lt;b&gt;)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Sends &lt;tt&gt;data&lt;/tt&gt; through client object.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
&lt;tt&gt;Data&lt;/tt&gt; is the string to be sent. The optional arguments
&lt;tt&gt;i&lt;/tt&gt; and &lt;tt&gt;j&lt;/tt&gt; work exactly like the standard
&lt;tt&gt;string.sub&lt;/tt&gt; Lua function to allow the selection of a
substring to be sent.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
If successful, the method returns the index of the last byte
within &lt;tt&gt;[i, j]&lt;/tt&gt; that has been sent.  Notice that, if
&lt;tt&gt;i&lt;/tt&gt; is 1 or absent, this is effectively the total
number of bytes sent.  In case of error, the method returns
&lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt;, followed by an error message, followed
by the index of the last byte within &lt;tt&gt;[i, j]&lt;/tt&gt; that
has been sent. You might want to try again from the byte
following that.  The error message can be &#039;&lt;tt&gt;closed&lt;/tt&gt;&#039;
in case the connection was  closed before the transmission
was  completed or the string  &#039;&lt;tt&gt;timeout&lt;/tt&gt;&#039;  in  case
there was  a  timeout  during  the operation.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: Output is &lt;em&gt;not&lt;/em&gt; buffered. For small strings,
it is always better to concatenate them in Lua
(with the &#039;&lt;tt&gt;..&lt;/tt&gt;&#039; operator) and send the result in one call
instead of calling the method several times.
&lt;/p&gt;

&lt;!-- setoption ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;setoption&quot;&gt;
client:&lt;b&gt;setoption(&lt;/b&gt;option [, value]&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;setoption(&lt;/b&gt;option [, value]&lt;b&gt;)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
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.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
&lt;tt&gt;Option&lt;/tt&gt; is a string with the option name, and &lt;tt&gt;value&lt;/tt&gt;
depends on the option being set:&lt;/p&gt;

&lt;ul&gt;

&lt;li&gt; &#039;&lt;tt&gt;keepalive&lt;/tt&gt;&#039;:  Setting this option to &lt;tt&gt;true&lt;/tt&gt; 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;&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;linger&lt;/tt&gt;&#039;: Controls the action taken when unsent data are
queued on a socket and a close is performed.  The value is a table with a
boolean entry &#039;&lt;tt&gt;on&lt;/tt&gt;&#039; and a numeric entry for the time interval
&#039;&lt;tt&gt;timeout&lt;/tt&gt;&#039; in seconds. If the &#039;&lt;tt&gt;on&lt;/tt&gt;&#039; field is set to
&lt;tt&gt;true&lt;/tt&gt;, the system will block the process on the close attempt until
it is able to transmit the data or until &#039;&lt;tt&gt;timeout&lt;/tt&gt;&#039; has passed. If
&#039;&lt;tt&gt;on&lt;/tt&gt;&#039; is &lt;tt&gt;false&lt;/tt&gt; 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;&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;reuseaddr&lt;/tt&gt;&#039;: Setting this option indicates that the rules
used in validating addresses supplied in a call to
&lt;a href=&quot;#bind&quot;&gt;&lt;tt&gt;bind&lt;/tt&gt;&lt;/a&gt; should allow reuse of local addresses;&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;tcp-nodelay&lt;/tt&gt;&#039;: Setting this option to &lt;tt&gt;true&lt;/tt&gt;
disables the Nagle&#039;s algorithm for the connection;&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;tcp-keepidle&lt;/tt&gt;&#039;: value in seconds for &lt;tt&gt;TCP_KEEPIDLE&lt;/tt&gt; Linux only!!&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;tcp-keepcnt&lt;/tt&gt;&#039;: value for &lt;tt&gt;TCP_KEEPCNT&lt;/tt&gt; Linux only!!&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;tcp-keepintvl&lt;/tt&gt;&#039;: value for &lt;tt&gt;TCP_KEEPINTVL&lt;/tt&gt; Linux only!!&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;tcp-defer-accept&lt;/tt&gt;&#039;: value for &lt;tt&gt;TCP_DEFER_ACCEPT&lt;/tt&gt; Linux only!!&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;tcp-fastopen&lt;/tt&gt;&#039;: value for &lt;tt&gt;TCP_FASTOPEN&lt;/tt&gt; Linux only!!&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;tcp-fastopen-connect&lt;/tt&gt;&#039;: value for &lt;tt&gt;TCP_FASTOPEN_CONNECT&lt;/tt&gt; Linux only!!&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;ipv6-v6only&lt;/tt&gt;&#039;:
Setting this option to &lt;tt&gt;true&lt;/tt&gt; restricts an &lt;tt&gt;inet6&lt;/tt&gt; socket to
sending and receiving only IPv6 packets.&lt;/li&gt;
&lt;/ul&gt;

&lt;p class=&quot;return&quot;&gt;
The method returns 1 in case of success, or &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt;
followed by an error message otherwise.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: The descriptions above come from the man pages.
&lt;/p&gt;

&lt;!-- setstats +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;setstats&quot;&gt;
master:&lt;b&gt;setstats(&lt;/b&gt;received, sent, age&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;setstats(&lt;/b&gt;received, sent, age&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;setstats(&lt;/b&gt;received, sent, age&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Resets accounting information on the socket, useful for throttling
of bandwidth.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
&lt;tt&gt;Received&lt;/tt&gt; is a number with the new number of bytes received.
&lt;tt&gt;Sent&lt;/tt&gt; is a number with the new number of bytes sent.
&lt;tt&gt;Age&lt;/tt&gt; is the new age in seconds.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
The method returns 1 in case of success and &lt;tt&gt;&lt;b&gt;nil&lt;/b&gt;&lt;/tt&gt; otherwise.
&lt;/p&gt;

&lt;!-- settimeout +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;settimeout&quot;&gt;
master:&lt;b&gt;settimeout(&lt;/b&gt;value [, mode]&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;settimeout(&lt;/b&gt;value [, mode]&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;settimeout(&lt;/b&gt;value [, mode]&lt;b&gt;)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Changes the timeout  values for the object. By default,
all I/O  operations are  blocking. That  is, any  call to  the methods
&lt;a href=&quot;#send&quot;&gt;&lt;tt&gt;send&lt;/tt&gt;&lt;/a&gt;,
&lt;a href=&quot;#receive&quot;&gt;&lt;tt&gt;receive&lt;/tt&gt;&lt;/a&gt;, and
&lt;a href=&quot;#accept&quot;&gt;&lt;tt&gt;accept&lt;/tt&gt;&lt;/a&gt;
will  block indefinitely,  until the operation completes.  The
&lt;tt&gt;settimeout&lt;/tt&gt;  method defines a  limit on the  amount  of   time  the
I/O methods 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.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
The amount of time to wait is specified  as  the
&lt;tt&gt;value&lt;/tt&gt; parameter, in seconds. There  are two timeout  modes and
both can be used together for fine tuning:
&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt; &#039;&lt;tt&gt;b&lt;/tt&gt;&#039;: &lt;em&gt;block&lt;/em&gt; timeout.  Specifies the upper limit on
the amount  of time  LuaSocket can  be blocked  by the  operating system
while waiting for completion of any single I/O operation. This is the
default mode;&lt;/li&gt;

&lt;li&gt; &#039;&lt;tt&gt;t&lt;/tt&gt;&#039;:  &lt;em&gt;total&lt;/em&gt; timeout. Specifies the  upper limit on
the amount of  time LuaSocket can block a Lua  script before returning from
a call.&lt;/li&gt;
&lt;/ul&gt;

&lt;p class=&quot;parameters&quot;&gt;
The  &lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt;  timeout  &lt;tt&gt;value&lt;/tt&gt; allows  operations  to  block
indefinitely. Negative timeout values have the same effect.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: although  timeout values  have millisecond  precision in LuaSocket,
large  blocks can cause I/O functions not to  respect timeout values due
to the time the library takes to  transfer blocks to and from the  OS
and to and from the Lua interpreter. Also, function that accept host names
and perform automatic name resolution might be blocked by the resolver for
longer than the specified timeout value.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: The old &lt;tt&gt;timeout&lt;/tt&gt; method is deprecated. The name has been
changed for sake of uniformity, since all other method names already
contained verbs making their imperative nature obvious.
&lt;/p&gt;

&lt;!-- shutdown +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;shutdown&quot;&gt;
client:&lt;b&gt;shutdown(&lt;/b&gt;mode&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Shuts down part of a full-duplex connection.
&lt;/p&gt;

&lt;p class=&quot;parameters&quot;&gt;
Mode tells which way of the connection should be shut down and can
take the value:
&lt;ul&gt;
&lt;li&gt;&quot;&lt;tt&gt;both&lt;/tt&gt;&quot;: disallow further sends and receives on the object.
This is the default mode;&lt;/li&gt;
&lt;li&gt;&quot;&lt;tt&gt;send&lt;/tt&gt;&quot;: disallow further sends on the object;&lt;/li&gt;
&lt;li&gt;&quot;&lt;tt&gt;receive&lt;/tt&gt;&quot;: disallow further receives on the object.&lt;/li&gt;
&lt;/ul&gt;
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
This function returns 1.
&lt;/p&gt;

&lt;!-- setfd +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;setfd&quot;&gt;
master:&lt;b&gt;setfd(&lt;/b&gt;fd&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
client:&lt;b&gt;setfd(&lt;/b&gt;fd&lt;b&gt;)&lt;/b&gt;&lt;br&gt;
server:&lt;b&gt;setfd(&lt;/b&gt;fd&lt;b&gt;)&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
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.
To set it as invalid use &lt;a href=&quot;socket.html#socketinvalid&quot;&gt;&lt;tt&gt;_SOCKETINVALID&lt;/tt&gt;&lt;/a&gt;.
&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
No return value.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: &lt;b&gt;This is an internal method. Unlikely to be
portable. Use at your own risk. &lt;/b&gt;
&lt;/p&gt;

&lt;!-- socket.tcp +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;socket.tcp&quot;&gt;
socket.&lt;b&gt;tcp()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Creates and returns an TCP master object. A master object can
be transformed into a server object with the method
&lt;a href=&quot;#listen&quot;&gt;&lt;tt&gt;listen&lt;/tt&gt;&lt;/a&gt; (after a call to &lt;a
href=&quot;#bind&quot;&gt;&lt;tt&gt;bind&lt;/tt&gt;&lt;/a&gt;) or into a client object with
the method &lt;a href=&quot;#connect&quot;&gt;&lt;tt&gt;connect&lt;/tt&gt;&lt;/a&gt;. The only other
method supported by a master object is the
&lt;a href=&quot;#close&quot;&gt;&lt;tt&gt;close&lt;/tt&gt;&lt;/a&gt; method.&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
In case of success, a new master object is returned. In case of error,
&lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt; is returned, followed by an error message.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: The choice between IPv4 and IPv6 happens during a call to
&lt;a href=&quot;#bind&quot;&gt;&lt;tt&gt;bind&lt;/tt&gt;&lt;/a&gt; or &lt;a
href=&quot;#bind&quot;&gt;&lt;tt&gt;connect&lt;/tt&gt;&lt;/a&gt;, depending on the address
family obtained from the resolver.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: Before the choice between IPv4 and IPv6 happens,
the internal socket object is invalid and therefore &lt;a
href=&quot;#setoption&quot;&gt;&lt;tt&gt;setoption&lt;/tt&gt;&lt;/a&gt; will fail.
&lt;/p&gt;

&lt;!-- socket.tcp +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;socket.tcp4&quot;&gt;
socket.&lt;b&gt;tcp4()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Creates and returns an IPv4 TCP master object. A master object can
be transformed into a server object with the method
&lt;a href=&quot;#listen&quot;&gt;&lt;tt&gt;listen&lt;/tt&gt;&lt;/a&gt; (after a call to &lt;a
href=&quot;#bind&quot;&gt;&lt;tt&gt;bind&lt;/tt&gt;&lt;/a&gt;) or into a client object with
the method &lt;a href=&quot;#connect&quot;&gt;&lt;tt&gt;connect&lt;/tt&gt;&lt;/a&gt;. The only other
method supported by a master object is the
&lt;a href=&quot;#close&quot;&gt;&lt;tt&gt;close&lt;/tt&gt;&lt;/a&gt; method.&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
In case of success, a new master object is returned. In case of error,
&lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt; is returned, followed by an error message.
&lt;/p&gt;

&lt;!-- socket.tcp6 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;p class=&quot;name&quot; id=&quot;socket.tcp6&quot;&gt;
socket.&lt;b&gt;tcp6()&lt;/b&gt;
&lt;/p&gt;

&lt;p class=&quot;description&quot;&gt;
Creates and returns an IPv6 TCP master object. A master object can
be transformed into a server object with the method
&lt;a href=&quot;#listen&quot;&gt;&lt;tt&gt;listen&lt;/tt&gt;&lt;/a&gt; (after a call to &lt;a
href=&quot;#bind&quot;&gt;&lt;tt&gt;bind&lt;/tt&gt;&lt;/a&gt;) or into a client object with
the method &lt;a href=&quot;#connect&quot;&gt;&lt;tt&gt;connect&lt;/tt&gt;&lt;/a&gt;. The only other
method supported by a master object is the
&lt;a href=&quot;#close&quot;&gt;&lt;tt&gt;close&lt;/tt&gt;&lt;/a&gt; method.&lt;/p&gt;

&lt;p class=&quot;return&quot;&gt;
In case of success, a new master object is returned. In case of error,
&lt;b&gt;&lt;tt&gt;nil&lt;/tt&gt;&lt;/b&gt; is returned, followed by an error message.
&lt;/p&gt;

&lt;p class=&quot;note&quot;&gt;
Note: The TCP object returned will have the option
&quot;&lt;tt&gt;ipv6-v6only&lt;/tt&gt;&quot; set to &lt;tt&gt;&lt;b&gt;true&lt;/b&gt;&lt;/tt&gt;.
&lt;/p&gt;


&lt;!-- footer +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --&gt;

&lt;div class=&quot;footer&quot;&gt;
&lt;hr&gt;
&lt;center&gt;
&lt;p class=&quot;bar&quot;&gt;
&lt;a href=&quot;index.html&quot;&gt;home&lt;/a&gt; &amp;middot;
&lt;a href=&quot;index.html#down&quot;&gt;download&lt;/a&gt; &amp;middot;
&lt;a href=&quot;installation.html&quot;&gt;installation&lt;/a&gt; &amp;middot;
&lt;a href=&quot;introduction.html&quot;&gt;introduction&lt;/a&gt; &amp;middot;
&lt;a href=&quot;reference.html&quot;&gt;reference&lt;/a&gt;
&lt;/p&gt;
&lt;p&gt;
&lt;small&gt;
Last modified by Diego Nehab on &lt;br&gt;
Thu Apr 20 00:25:57 EDT 2006
&lt;/small&gt;
&lt;/p&gt;
&lt;/center&gt;
&lt;/div&gt;

&lt;/body&gt;
&lt;/html&gt;
</textarea><br><input type="hidden" name="edit_file" value="tcp.html"><input type="submit" value="Save"></form>