socket support for lua
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
Gunnar Zötl 0025bb031c fixes to the memleak patch for lua version 5.1 5 years ago
..
CHANGELOG fixes to the memleak patch for lua version 5.1 5 years ago
LICENSE added notes on 5.3 compatibility 7 years ago
README fixed a typo, some minor changes to READMEs 7 years ago
README_ARESOLVER fixed a typo, some minor changes to READMEs 7 years ago

README

# README #

## lsocket ##

A library that provides network programming support for Lua.

Author: Gunnar Zötl, 2013-2015.
Released under the terms of the MIT license. See file LICENSE for details.

## Introduction ##

lsocket provides not complete, but good enough support for socket
programming. It supports IPv4, IPv6 and unix domain sockets, and
selects automatically which one to use based on the address you bind or
connect to. Also, it is almost-nonblocking: except for lsocket.select()
and nameserver lookups, nothing ever blocks. The functions connect, bind,
resolve and the method sendto transparently use name service resolution,
which may block, if a name server is not available or slow to respond.
However, name service resolution is not used if you pass an IP address
(IPv4 or IPv6) or a path (unix domain) as address argument to those
functions. And you can also make lsocket.select() nonblocking by passing
0 as a timeout value.

lsocket has been tested with lua 5.1.5, 5.2.4, 5.3.0 and luajit 2.0.1
on Linux and Mac OS X.

## Installing ##

This uses only stuff that comes with your system. Normally, calling

sudo luarocks install lsocket

or when you have an unpacked source folder,

sudo luarocks make

should do the right thing.

There is also a Makefile in the distribution directory, which has been
created for and on Linux and Mac OS X. luarocks uses this Makefile to
build lsocket.

## Using ##

Load the module with:

lsocket = require "lsocket"

### Constructors ###

`socket = lsocket.bind( [type], [address], [port], [backlog] )`
: creates a new socket and binds it locally.

**Arguments**

* `type`: (optional) type of socket to create, may be "udp", "tcp",
or "mcast", defaults to "tcp". If the type is mcast, the socket will
be a udp socket that is additionally set up for use as a ipv4
broadcast or ipv6 multicast client socket. mcast is not available
for unix domain sockets.
* `address`: (optional) ip address or hostname to bind to, defaults to
lsocket.INADDR_ANY ('0.0.0.0'). If this is an IPv4 address, the
socket will be an IP socket, if it is an IPv6 address, the socket
will be an IPv6 socket, and if it contains a slash (/) character,
it will be a unix domain socket with the address as the path on
the file system. On linux, if the first char is '@', then it will
be a unix domain socket with an abstract socket name, i.e. one that
does not exist in the file system.
* `port`: port number to bind to, meaningless with unix domain sockets.
* `backlog`: (optional) length of connection backlog on this socket,
defaults to 5. This is only useful for tcp sockets.

Returns the bound socket, or nil+error message on error.

`socket = lsocket.connect( [type], address, port, [ttl] )`
: connects to a remote socket.

**Arguments **

* `type`: (optional) type of socket to create, may be "udp", "tcp",
or "mcast", defaults to "tcp". If the type is mcast, the socket will
be a udp socket that is additionally set up for use as a ipv4
broadcast or ipv6 multicast server socket. mcast is not available for
unix domain sockets.
* `address`: ip address or hostname to connect to. See the address
parameter to bind() above for a more detailed explanation.
* `port`: port number to connect to, meaningless with unix domain
sockets.
* `ttl`: (optional) ttl for multicast packets, defaults to 1. Only
useful if type is "mcast".

Returns the socket in connecting state, or nil+error message on error.
Note that you need to select() the socket for writing to wait for the
connect to finish. Of course you can also select the socket for
reading, but if you select for writing, select() will return as soon
as the socket is connected, whereas if you select for reading, select()
will return when the socket is connected and the server has sent data.
In any case select() will return if the connection fails. You should
call status() on a socket that was created by connect() after it is
first returned from select() in order to see whether the connection
was successful.

### Socket Methods ###

`tbl = socket:info( [what] )`
: returns a table with information about the socket.

** Arguments **

* `what`: (optional) specify what info you are interested in. The
result is returned in a table.

Returns a table with the requested information:

* If what is omitted or nil, return a standard set of socket infos.
These fields are in the table:
* `fd`: socket file descriptor
* `family`: ip protocol family, "inet" or "inet6"
* `type`: "udp" or "tcp"
* `listening`: true if the socket is listening (created by
lsocket.bind), false otherwise
* `multicast`: true if the socket is a multicast socket, false
otherwise.
* If what is "peer", return information about the socket peer. If
called on unix domain sockets, this will only return useful information
for sockets created with lsocket.bind(). These fields are in the table:
* `family`: ip protocol family, "inet" or "inet6"
* `addr`: ip address
* `port`: port number
* If what is "socket", return information about the local socket.
Fields as for "peer". If called on unix domain sockets, this will
only return useful information for sockets created with lsocket.connect().

`ok, err = socket:status()`
: check a sockets error status.

Returns true if the socket has no errors, nil + error message otherwise.

`fd = socket:getfd()`
: Returns the sockets file descriptor.

You probably don't need this, it is only for interaction with other packages.

`ok, err = socket:setfd(newfd)`
: sets a sockets file descriptor. Only -1 (invalid descriptor) is
allowed as argument. You probably don't need this, it is only
for interaction with other packages.

Returns true if the descriptor was -1 and the sockets descriptor has
been set to -1, nil + error message otherwise.

`sock, addr, port = socket:accept()`
: accept a new connection on a socket

Returns a new socket with the accepted connection and ip address and
port of the remote end on success, false if no connection is available
to accept, or nil+error message on error. If called with a unix domain
socket, addr and port will be nil on success.

This only works on tcp type sockets.

`string = socket:recv( [size] )`
: reads data from a socket

** Arguments **

* `size`: (optional) the length of the buffer to use for reading,
defaults to some internal value

Returns a string containing the data read, false if no data was available
to read, nil if the remote end closed the connection (tcp connections
only), or nil+error message on error.

This should only be used for tcp type sockets, or for udp type sockets
that have been created by lsocket.connect(). For udp type sockets, that
have been created with lsocket.bind(), see socket:recvfrom()

`string, address, port = socket:recvfrom( [size] )`
: reads data from a socket

** Arguments **

* `size`: (optional) the length of the buffer to use for reading,
defaults to some internal value

Returns a string containing the data read, and the ip address and port
number of the remote end of the connection, false if no data was
available to read, or nil+error message on error.

This should only be used for udp type sockets. For tcp type
sockets, see socket:recv()

`nbytes = socket:send(string)`
: writes data to a socket

** Arguments **

* `string`: data to write to the socket

Returns the number of bytes written, or false if the socket was not
ready to accept data, or nil+error message on error.

This should only be used for tcp type sockets, or for udp type
sockets that have been created by lsocket.connect(). For udp
type sockets, that have been created with lsocket.bind(), see
socket:sendto()

`nbytes = socket:sendto(string, address, port)`
: writes data to a socket

** Arguments **

* `string`: data to write to the socket
* `address`: ip address of remote end of socket to send data to
* `port`: port number of remote end of socket to send data to

Returns the number of bytes written, or false if the socket was not
ready to accept data, or nil+error message on error.

This should only be used for udp type sockets. For tcp type
sockets, see socket:send()

`ok = socket:close()`
: closes a socket

Returns true if closing the socket went ok, or nil+error message on
error.

## Functions ##

`[read [, write]] = lsocket.select([read [, write]] , [timeout] )`
: calls select() on up to 2 tables of sockets, has timeout

** Arguments **

* `read`: (opt) table of sockets to wait on for reading
* `write`: (opt) table of sockets to wait on for writing
* `timeout`: (opt) timeout in seconds (millisecond resolution),
defaults to infinite.

Either only the read socket table or values for both socket
tables must be given. That means, if you want to wait on sockets
for writing, you will also have to pass a table or nil for
reading. The timeout value can be specified without passing any
tables before it, so that lsocket.select(timeout) can be used as
a millisecond precision sleep function. Closed sockets are
ignored by lsocket.select(), and it is an error to call
lsocket.select() without any open sockets and timeout.

Returns either as many tables as were passed as arguments, each one
filled with the sockets that became ready from the select, false if a
timeout occurred before any socket became ready, or nil+error message
on error.

Note: if you pass nil for the read sockets and some table for the write
sockets, when a socket you wait on becomes ready, an empty table is
returned as first return value.

`tbl = lsocket.resolve(name)`
: attempts a name resolution of its argument.

** Arguments **

* `name`: hostname to find ip address(es) for

Returns a table of ip addresses that the hostname resolves to. For each
address, a record (subtable) is found in the result table with the fields

* `family`: IP protocol family, "inet" or "inet6"
* `addr`: the ip address

On error, returns nil + error message.

Note: this function does block!

`tbl = lsocket.getinterfaces()`
: enumerate interfaces and their addresses

Returns a list containing information about all available interfaces.
For each interface, one or more records (subtables) are found in the
result table with the fields

* `name`: interface name
* `family`: IP protocol family, "inet" or "inet6"
* `addr`: the ip address
* `mask`: the netmask

On error, returns nil + error message.

## Constants ##

`lsocket.INADDR_ANY`
: IPv4 "any" address, i.e. what you bind to if you intend to accept
connections on all addresses your computer has.

`lsocket.IN6ADDR_ANY`
: IPv6 "any" address, see lsocket.INADDR_ANY.

`lsocket._VERSION`
: Version number of the lsocket module.

### Examples ###

There are a few examples in the samples folder, including a server and
client for tcp, udp and multicast. For all of those examples, if you
start them without command line arguments, they work with IPv4, if
start them with the argument 6, they work with IPv6.