luasocket/src/luasocket.c

2016 lines
69 KiB
C
Raw Normal View History

2000-06-02 19:55:14 +02:00
/*=========================================================================*\
* IPv4 Sockets for the Lua language
2000-06-02 19:55:14 +02:00
* Diego Nehab
* 26/11/1999
*
* Module: luasocket.c
2000-06-02 19:55:14 +02:00
*
* This module is part of an effort to make the most important features
* of the IPv4 Socket layer available to Lua scripts.
2000-06-02 19:55:14 +02:00
* The Lua interface to TCP/IP follows the BSD TCP/IP API closely,
* trying to simplify all tasks involved in setting up a client connection
* and simple server connections.
* The provided IO routines, send and receive, follow the Lua style, being
* very similar to the read and write functions found in that language.
* The module implements both a BSD bind and a Winsock2 bind, and has
* been tested on several Unix flavors, as well as Windows 98 and NT.
\*=========================================================================*/
/*=========================================================================*\
* Common include files
\*=========================================================================*/
#include <assert.h>
#include <errno.h>
#include <signal.h>
2000-06-02 19:55:14 +02:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <lauxlib.h>
#include <lua.h>
2000-06-02 19:55:14 +02:00
#include <lualib.h>
#include "luasocket.h"
2000-06-02 19:55:14 +02:00
/*=========================================================================*\
* WinSock2 include files
\*=========================================================================*/
#ifdef WIN32
#include <winsock2.h>
#include <winbase.h>
#else
2000-06-02 19:55:14 +02:00
/*=========================================================================*\
* BSD include files
\*=========================================================================*/
/* close function */
#include <unistd.h>
/* fnctnl function and associated constants */
#include <fcntl.h>
/* struct timeval and CLK_TCK */
#include <sys/time.h>
/* times function and struct tms */
#include <sys/times.h>
/* internet protocol definitions */
#include <netinet/in.h>
#include <arpa/inet.h>
/* struct sockaddr */
#include <sys/types.h>
/* socket function */
#include <sys/socket.h>
/* gethostbyname and gethostbyaddr functions */
#include <netdb.h>
#endif
/*=========================================================================*\
* Datatype compatibilization and some simple changes
\*=========================================================================*/
#ifndef WIN32
/* WinSock2 has a closesock function instead of the regular close */
#define closesocket close
/* it defines a SOCKET type instead of using an integer file descriptor */
#define SOCKET int
/* and uses the this macro to represent and invalid socket */
#define INVALID_SOCKET (-1)
/* SunOS, does not define CLK_TCK */
#ifndef CLK_TCK
#define CLK_TCK 60
2000-06-02 19:55:14 +02:00
#endif
#endif
/*=========================================================================*\
* Module definitions
\*=========================================================================*/
/*-------------------------------------------------------------------------*\
* The send and receive function can return one of the following return
* codes. The values are mapped into Lua values by the function
* push_error.
\*-------------------------------------------------------------------------*/
#define NET_DONE -1 /* operation completed successfully */
#define NET_TIMEOUT 0 /* operation timed out */
#define NET_CLOSED 1 /* the connection has been closed */
#define NET_REFUSED 2 /* the data transfer has been refused */
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Time out mode to be checked
\*-------------------------------------------------------------------------*/
#define TM_RECEIVE 1
#define TM_SEND 2
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Each socket is represented by a table with the supported methods and
* the p_sock structure as fields.
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
#define P_SOCK "(p_sock)sock"
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Both socket types are stored in the same structure to simplify
* implementation. The tag value used is different, though.
* The buffer parameters are not used by server and UDP sockets.
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
typedef struct t_sock {
/* operating system socket object */
SOCKET sock;
/* start time of the current operation */
int tm_start;
/* return and blocking timeout values (-1 if no limit) */
int tm_return, tm_block;
/* buffered I/O storage */
unsigned char bf_buffer[LUASOCKET_TCPBUFFERSIZE];
/* first and last red bytes not yet passed to application */
int bf_first, bf_last;
/* is this udp socket in "connected" state? */
int is_connected;
#ifdef _DEBUG
/* end time of current operation, for debug purposes */
int tm_end;
#endif
2000-06-02 19:55:14 +02:00
} t_sock;
typedef t_sock *p_sock;
/*-------------------------------------------------------------------------*\
* Tags passed as closure values to global LuaSocket API functions
\*-------------------------------------------------------------------------*/
typedef struct t_tags {
int client, server, table, udp;
} t_tags;
typedef t_tags *p_tags;
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Macros and internal declarations
\*-------------------------------------------------------------------------*/
/* min and max macros */
#ifndef MIN
#define MIN(x, y) ((x) < (y) ? x : y)
2000-06-02 19:55:14 +02:00
#endif
#ifndef MAX
#define MAX(x, y) ((x) > (y) ? x : y)
2000-06-02 19:55:14 +02:00
#endif
/* we are lazy.. */
typedef struct sockaddr SA;
/*=========================================================================*\
* Internal function prototypes
\*=========================================================================*/
/* luasocket global API functions */
static int global_tcpconnect(lua_State *L);
static int global_tcpbind(lua_State *L);
static int global_select(lua_State *L);
static int global_toip(lua_State *L);
static int global_tohostname(lua_State *L);
static int global_udpsocket(lua_State *L);
/* luasocket table method API functions */
static int table_tcpaccept(lua_State *L);
static int table_tcpsend(lua_State *L);
static int table_tcpreceive(lua_State *L);
static int table_udpsendto(lua_State *L);
static int table_udpreceivefrom(lua_State *L);
static int table_udpsetpeername(lua_State *L);
static int table_timeout(lua_State *L);
static int table_close(lua_State *L);
static int table_getpeername(lua_State *L);
static int table_getsockname(lua_State *L);
/* buffered I/O management */
static const unsigned char *bf_receive(p_sock sock, int *length);
static void bf_skip(p_sock sock, int length);
static int bf_isempty(p_sock sock);
/* timeout management */
static int tm_timedout(p_sock sock, int mode);
static int tm_gettimeleft(p_sock sock);
static int tm_gettime(void);
static void tm_markstart(p_sock sock);
/* I/O */
static int send_raw(p_sock sock, const char *data, int wanted, int *err);
static int receive_raw(lua_State *L, p_sock sock, int wanted);
static int receive_dosline(lua_State *L, p_sock sock);
static int receive_unixline(lua_State *L, p_sock sock);
static int receive_all(lua_State *L, p_sock sock);
/* parameter manipulation functions */
static p_tags pop_tags(lua_State *L);
static p_sock pop_sock(lua_State *L);
static p_sock get_sock(lua_State *L, int s, p_tags tags, int *tag);
static p_sock get_selfsock(lua_State *L, p_tags tags, int *tag);
static p_sock push_servertable(lua_State *L, p_tags tags);
static p_sock push_clienttable(lua_State *L, p_tags tags);
static p_sock push_udptable(lua_State *L, p_tags tags);
static void push_error(lua_State *L, int err);
static void push_resolved(lua_State *L, struct hostent *hp);
/* error code translations functions */
static char *host_strerror(void);
static char *bind_strerror(void);
static char *socket_strerror(void);
static char *connect_strerror(void);
/* socket auxiliary functions */
const char *tcp_trybind(p_sock sock, const char *address,
unsigned short port, int backlog);
const char *tcp_tryconnect(p_sock sock, const char *address,
unsigned short port);
const char *udp_setpeername(p_sock sock, const char *address,
unsigned short port);
const char *udp_setsockname(p_sock sock, const char *address,
unsigned short port);
static void set_reuseaddr(p_sock sock);
static void set_blocking(p_sock sock);
static void set_nonblocking(p_sock sock);
#ifdef WIN32
static int winsock_open(void);
#define LUASOCKET_ATON
#endif
#ifdef LUASOCKET_ATON
static int inet_aton(const char *cp, struct in_addr *inp);
#endif
/* tag methods */
static int gc_table(lua_State *L);
2000-06-02 19:55:14 +02:00
/*=========================================================================*\
* Test support functions
\*=========================================================================*/
#ifdef _DEBUG
/*-------------------------------------------------------------------------*\
* Returns the time the system has been up, in secconds.
\*-------------------------------------------------------------------------*/
static int global_time(lua_State *L);
static int global_time(lua_State *L)
2000-06-02 19:55:14 +02:00
{
lua_pushnumber(L, tm_gettime()/1000.0);
return 1;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Causes a Lua script to sleep for the specified number of secconds
\*-------------------------------------------------------------------------*/
static int global_sleep(lua_State *L);
static int global_sleep(lua_State *L)
2000-06-02 19:55:14 +02:00
{
int sec = (int) luaL_check_number(L, 1);
#ifdef WIN32
Sleep(1000*sec);
#else
sleep(sec);
#endif
return 0;
2000-06-02 19:55:14 +02:00
}
#endif
/*=========================================================================*\
* Lua exported functions
* These functions can be accessed from a Lua script.
\*=========================================================================*/
/*-------------------------------------------------------------------------*\
* Creates a client socket and returns it to the Lua script. The timeout
* values are initialized as -1 so that the socket will block at any
* IO operation.
* Lua Input: address, port
* address: host name or ip address to connect to
2000-06-02 19:55:14 +02:00
* port: port number on host
* Lua Returns
* On success: client socket object
2000-06-02 19:55:14 +02:00
* On error: nil, followed by an error message
\*-------------------------------------------------------------------------*/
static int global_tcpconnect(lua_State *L)
{
p_tags tags = pop_tags(L);
const char *address = luaL_check_string(L, 1);
unsigned short port = (unsigned short) luaL_check_number(L, 2);
p_sock sock = push_clienttable(L, tags);
const char *err;
if (!sock) {
lua_pushnil(L);
lua_pushstring(L, "out of memory");
return 2;
}
err = tcp_tryconnect(sock, address, port);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
set_nonblocking(sock);
return 1;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Creates a udp socket object and returns it to the Lua script.
* The timeout values are initialized as -1 so that the socket will block
* at any IO operation.
* Lua Returns
* On success: udp socket
* On error: nil, followed by an error message
\*-------------------------------------------------------------------------*/
static int global_udpsocket(lua_State *L)
{
p_tags tags = pop_tags(L);
p_sock sock = push_udptable(L, tags);
if (!sock) return 2;
return 1;
}
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Waits for and returns a client socket object attempting connection
* with a server socket. The function blocks until a client shows up or
* until a timeout condition is met.
* Lua Input: sock
2000-06-02 19:55:14 +02:00
* sock: server socket created by the bind function
* Lua Returns
* On success: client socket attempting connection
* On error: nil followed by an error message
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int table_tcpaccept(lua_State *L)
2000-06-02 19:55:14 +02:00
{
struct sockaddr_in client_addr;
size_t client_len = sizeof(client_addr);
p_sock server = pop_sock(L);
p_tags tags = pop_tags(L);
p_sock client = push_clienttable(L, tags);
tm_markstart(server);
if (tm_gettimeleft(server) >= 0) {
set_nonblocking(server);
do {
if (tm_timedout(server, TM_RECEIVE)) {
lua_pushnil(L);
push_error(L, NET_TIMEOUT);
return 2;
}
client->sock = accept(server->sock, (SA *) &client_addr,
&client_len);
} while (client->sock == INVALID_SOCKET);
} else {
set_blocking(server);
client->sock = accept(server->sock, (SA *) &client_addr, &client_len);
}
set_nonblocking(client);
return 1;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Associates an address to a server socket.
* Lua Input: address, port [, backlog]
* address: host name or ip address to bind to
* port: port to bind to
* backlog: connection queue length (default: 1)
* Lua Returns
* On success: server socket bound to address
* On error: nil, followed by an error message
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int global_tcpbind(lua_State *L)
2000-06-02 19:55:14 +02:00
{
p_tags tags = pop_tags(L);
const char *address = luaL_check_string(L, 1);
unsigned short port = (unsigned short) luaL_check_number(L, 2);
int backlog = (int) luaL_opt_number(L, 3, 1);
p_sock sock = push_servertable(L, tags);
const char *err;
if (!sock) {
lua_pushnil(L);
lua_pushstring(L, "out of memory");
return 2;
}
err = tcp_trybind(sock, address, port, backlog);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
return 1;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Associates a local address to UDP socket
* Lua Input: address, port
* address: host name or ip address to bind to
2000-06-02 19:55:14 +02:00
* port: port to bind to
* Lua Returns
* On success: nil
* On error: error message
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int table_udpsetsockname(lua_State *L)
{
p_sock sock = pop_sock(L);
const char *address = luaL_check_string(L, 2);
unsigned short port = (unsigned short) luaL_check_number(L, 3);
const char *err = udp_setsockname(sock, address, port);
if (err) {
lua_pushstring(L, err);
return 1;
}
lua_pushnil(L);
return 1;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Sets a peer for a UDP socket
* Lua Input: address, port
* address: remote host name
* port: remote host port
* Lua Returns
* On success: nil
* On error: error message
\*-------------------------------------------------------------------------*/
static int table_udpsetpeername(lua_State *L)
{
p_sock sock = pop_sock(L);
const char *address = luaL_check_string(L, 2);
unsigned short port = (unsigned short) luaL_check_number(L, 3);
const char *err = udp_setpeername(sock, address, port);
if (err) {
lua_pushstring(L, err);
return 1;
}
sock->is_connected = 1;
lua_pushnil(L);
return 1;
}
/*-------------------------------------------------------------------------*\
* Sets timeout values for IO operations on a socket
* Lua Input: sock, time [, mode]
2000-06-02 19:55:14 +02:00
* sock: client socket created by the connect function
* time: time out value in seconds
* mode: "b" for block timeout, "r" for return timeout. (default: b)
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int table_timeout(lua_State *L)
2000-06-02 19:55:14 +02:00
{
p_sock sock = pop_sock(L);
int ms = lua_isnil(L, 2) ? -1 : (int) (luaL_check_number(L, 2)*1000.0);
const char *mode = luaL_opt_string(L, 3, "b");
switch (*mode) {
case 'b':
sock->tm_block = ms;
break;
case 'r':
sock->tm_return = ms;
break;
default:
luaL_arg_check(L, 0, 3, "invalid timeout mode");
break;
}
return 0;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Send data through a TCP socket
* Lua Input: sock, a_1 [, a_2, a_3 ... a_n]
2000-06-02 19:55:14 +02:00
* sock: client socket created by the connect function
* a_i: strings to be sent. The strings will be sent on the order they
* appear as parameters
* Lua Returns
2000-06-02 19:55:14 +02:00
* On success: nil, followed by the total number of bytes sent
* On error: error message
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int table_tcpsend(lua_State *L)
2000-06-02 19:55:14 +02:00
{
int arg;
p_sock sock = pop_sock(L);
int top = lua_gettop(L);
int total = 0;
int err = NET_DONE;
tm_markstart(sock);
for (arg = 2; arg <= top; arg++) { /* skip self table */
int sent;
size_t wanted;
const char *data = luaL_opt_lstr(L, arg, NULL, &wanted);
if (!data || err != NET_DONE) break;
err = send_raw(sock, data, wanted, &sent);
total += sent;
}
push_error(L, err);
lua_pushnumber(L, total);
2000-06-02 19:55:14 +02:00
#ifdef _DEBUG
/* push time elapsed during operation as the last return value */
lua_pushnumber(L, (sock->tm_end - sock->tm_start)/1000.0);
2000-06-02 19:55:14 +02:00
#endif
return lua_gettop(L) - top;
}
/*-------------------------------------------------------------------------*\
* Send data through a unconnected UDP socket
* Lua Input: sock, data, ip, port
* sock: udp socket
* data: data to be sent
* ip: ip address of target
* port: port in target
* Lua Returns
* On success: nil, followed by the total number of bytes sent
* On error: error message
\*-------------------------------------------------------------------------*/
static int table_udpsendto(lua_State *L)
{
p_sock sock = pop_sock(L);
size_t wanted;
const char *data = luaL_check_lstr(L, 2, &wanted);
const char *ip = luaL_check_string(L, 3);
unsigned short port = (unsigned short) luaL_check_number(L, 4);
struct sockaddr_in peer;
int sent;
if (sock->is_connected) lua_error(L, "sendto on connected socket");
tm_markstart(sock);
if (tm_timedout(sock, TM_SEND)) {
push_error(L, NET_TIMEOUT);
return 1;
}
memset(&peer, 0, sizeof(peer));
peer.sin_family = AF_INET;
peer.sin_port = htons(port);
if (!inet_aton(ip, &peer.sin_addr)) lua_error(L, "invalid ip address");
sent = sendto(sock->sock, data, wanted, 0, (SA *) &peer, sizeof(peer));
if (sent >= 0) {
lua_pushnil(L);
lua_pushnumber(L, sent);
return 2;
} else {
push_error(L, NET_REFUSED);
return 1;
}
}
/*-------------------------------------------------------------------------*\
* Waits for a set of sockets until a condition is met or timeout.
* Lua Input: {input}, {output} [, timeout]
* {input}: table of sockets to be tested for input
* {output}: table of sockets to be tested for output
* timeout: maximum amount of time to wait for condition, in seconds
* Lua Returns: {input}, {output}, err
* {input}: table with sockets ready for input
* {output}: table with sockets ready for output
* err: "timeout" or nil
\*-------------------------------------------------------------------------*/
int global_select(lua_State *L)
{
p_tags tags = pop_tags(L);
int ms = lua_isnil(L, 3) ? -1 : (int) (luaL_opt_number(L, 3, -1) * 1000);
fd_set readfds, *prfds = NULL, writefds, *pwfds = NULL;
struct timeval tm, *ptm = NULL;
int ret, s, max = -1;
int byfds, canread, canwrite;
/* reset the file descriptor sets */
FD_ZERO(&readfds); FD_ZERO(&writefds);
/* all sockets, indexed by socket number, for internal use */
lua_newtable(L); byfds = lua_gettop(L);
/* readable sockets table to be returned */
lua_newtable(L); canread = lua_gettop(L);
/* writable sockets table to be returned */
lua_newtable(L); canwrite = lua_gettop(L);
/* get sockets we will test for readability into fd_set */
if (!lua_isnil(L, 1)) {
lua_pushnil(L);
while (lua_next(L, 1)) {
if (lua_tag(L, -1) == tags->table) {
p_sock sock = get_sock(L, -1, tags, NULL);
lua_pushnumber(L, sock->sock);
lua_pushvalue(L, -2);
lua_settable(L, byfds);
if (sock->sock > max) max = sock->sock;
/* a socket can have unread data in our internal buffer. in
* that case, we only call select to find out which of the
* other sockets can be written to or read from immediately. */
if (!bf_isempty(sock)) {
ms = 0;
lua_pushnumber(L, lua_getn(L, canread) + 1);
lua_pushvalue(L, -2);
lua_settable(L, canread);
} else {
FD_SET(sock->sock, &readfds);
prfds = &readfds;
}
}
/* get rid of lua_next value and expose index */
lua_pop(L, 1);
}
}
/* get sockets we will test for writability into fd_set */
if (!lua_isnil(L, 2)) {
lua_pushnil(L);
while (lua_next(L, 2)) {
if (lua_tag(L, -1) == tags->table) {
p_sock sock = get_sock(L, -1, tags, NULL);
lua_pushnumber(L, sock->sock);
lua_pushvalue(L, -2);
lua_settable(L, byfds);
if (sock->sock > max) max = sock->sock;
FD_SET(sock->sock, &writefds);
pwfds = &writefds;
}
/* get rid of lua_next value and expose index */
lua_pop(L, 1);
}
}
max++;
/* configure timeout value */
if (ms >= 0) {
ptm = &tm; /* ptm == NULL when we don't have timeout */
/* fill timeval structure */
tm.tv_sec = ms / 1000;
tm.tv_usec = (ms % 1000) * 1000;
}
/* see if we can read, write or if we timedout */
ret = select(max, prfds, pwfds, NULL, ptm);
/* did we timeout? */
if (ret <= 0 && ms > 0) {
push_error(L, NET_TIMEOUT);
return 3;
}
/* collect readable sockets */
if (prfds) {
for (s = 0; s < max; s++) {
if (FD_ISSET(s, prfds)) {
lua_pushnumber(L, lua_getn(L, canread) + 1);
lua_pushnumber(L, s);
lua_gettable(L, byfds);
lua_settable(L, canread);
}
}
}
/* collect writable sockets */
if (pwfds) {
for (s = 0; s < max; s++) {
if (FD_ISSET(s, pwfds)) {
lua_pushnumber(L, lua_getn(L, canwrite) + 1);
lua_pushnumber(L, s);
lua_gettable(L, byfds);
lua_settable(L, canwrite);
}
}
}
lua_pushnil(L);
return 3;
}
/*-------------------------------------------------------------------------*\
* Returns the list of ip addresses associated with a host name
* Lua Input: address
* address: ip address or hostname to dns lookup
* Lua Returns
* On success: first IP address followed by a resolved table
* On error: nil, followed by an error message
\*-------------------------------------------------------------------------*/
static int global_toip(lua_State *L)
{
const char *address = luaL_check_string(L, 1);
struct in_addr addr;
struct hostent *hp;
if (inet_aton(address, &addr))
hp = gethostbyaddr((char *) &addr, sizeof(addr), AF_INET);
else hp = gethostbyname(address);
if (!hp) {
lua_pushnil(L);
lua_pushstring(L, host_strerror());
return 2;
}
addr = *((struct in_addr *) hp->h_addr);
lua_pushstring(L, inet_ntoa(addr));
push_resolved(L, hp);
return 2;
}
/*-------------------------------------------------------------------------*\
* Returns the list of host names associated with an ip address
* Lua Input: address
* address: ip address or host name to reverse dns lookup
* Lua Returns
* On success: canonic name followed by a resolved table
* On error: nil, followed by an error message
\*-------------------------------------------------------------------------*/
static int global_tohostname(lua_State *L)
{
const char *address = luaL_check_string(L, 1);
struct in_addr addr;
struct hostent *hp;
if (inet_aton(address, &addr))
hp = gethostbyaddr((char *) &addr, sizeof(addr), AF_INET);
else hp = gethostbyname(address);
if (!hp) {
lua_pushnil(L);
lua_pushstring(L, host_strerror());
return 2;
}
lua_pushstring(L, hp->h_name);
push_resolved(L, hp);
return 2;
}
/*-------------------------------------------------------------------------*\
* Send data through a connected UDP socket
* Lua Input: sock, data
* sock: udp socket
* data: data to be sent
* Lua Returns
* On success: nil, followed by the total number of bytes sent
* On error: error message
\*-------------------------------------------------------------------------*/
static int table_udpsend(lua_State *L)
{
p_sock sock = pop_sock(L);
size_t wanted;
int sent;
const char *data = luaL_check_lstr(L, 2, &wanted);
if (!sock->is_connected) lua_error(L, "send on unconnected socket");
tm_markstart(sock);
if (tm_timedout(sock, TM_SEND)) {
push_error(L, NET_TIMEOUT);
return 1;
}
sent = send(sock->sock, data, wanted, 0);
if (sent >= 0) {
lua_pushnil(L);
lua_pushnumber(L, sent);
return 2;
} else {
push_error(L, NET_REFUSED);
return 1;
}
}
/*-------------------------------------------------------------------------*\
* Receives a datagram from a UDP socket
* Lua Input: sock [, wanted]
* sock: client socket created by the connect function
* wanted: the number of bytes expected (default: LUASOCKET_UDPBUFFERSIZE)
* Lua Returns
* On success: datagram received, ip and port of sender
* On error: nil, followed by an error message
\*-------------------------------------------------------------------------*/
static int table_udpreceivefrom(lua_State *L)
{
p_sock sock = pop_sock(L);
size_t wanted = (int) luaL_opt_number(L, 2, LUASOCKET_UDPBUFFERSIZE);
struct sockaddr_in peer;
size_t peer_len = sizeof(peer);
unsigned char buffer[LUASOCKET_UDPBUFFERSIZE];
int got;
if (sock->is_connected) lua_error(L, "receivefrom on connected socket");
tm_markstart(sock);
if (tm_timedout(sock, TM_RECEIVE)) {
lua_pushnil(L);
push_error(L, NET_TIMEOUT);
return 2;
}
wanted = MIN(wanted, sizeof(buffer));
got = recvfrom(sock->sock, buffer, wanted, 0, (SA *) &peer, &peer_len);
if (got >= 0) {
lua_pushlstring(L, buffer, got);
lua_pushstring(L, inet_ntoa(peer.sin_addr));
lua_pushnumber(L, ntohs(peer.sin_port));
return 3;
} else {
lua_pushnil(L);
push_error(L, NET_REFUSED);
return 2;
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Receives data from a UDP socket
* Lua Input: sock [, wanted]
* sock: client socket created by the connect function
* wanted: the number of bytes expected (default: LUASOCKET_UDPBUFFERSIZE)
* Lua Returns
* On success: datagram received
* On error: nil, followed by an error message
\*-------------------------------------------------------------------------*/
static int table_udpreceive(lua_State *L)
{
p_sock sock = pop_sock(L);
size_t wanted = (size_t) luaL_opt_number(L, 2, LUASOCKET_UDPBUFFERSIZE);
unsigned char buffer[LUASOCKET_UDPBUFFERSIZE];
int got;
tm_markstart(sock);
if (tm_timedout(sock, TM_RECEIVE)) {
lua_pushnil(L);
push_error(L, NET_TIMEOUT);
return 2;
}
got = recv(sock->sock, buffer, MIN(wanted, sizeof(buffer)), 0);
if (got >= 0) {
lua_pushlstring(L, buffer, got);
return 1;
} else {
lua_pushnil(L);
push_error(L, NET_REFUSED);
return 2;
}
}
/*-------------------------------------------------------------------------*\
* Receive data from a TCP socket
* Lua Input: sock [pat_1, pat_2 ... pat_n]
2000-06-02 19:55:14 +02:00
* sock: client socket created by the connect function
* pat_i: may be one of the following
* "*l": reads a text line, defined as a string of caracters terminates
* by a LF character, preceded or not by a CR character. This is
* the default pattern
* "*lu": reads a text line, terminanted by a CR character only. (Unix mode)
* "*a": reads until connection closed
2000-06-02 19:55:14 +02:00
* number: reads 'number' characters from the socket
* Lua Returns
2000-06-02 19:55:14 +02:00
* On success: one string for each pattern
* On error: all strings for which there was no error, followed by one
* nil value for the remaining strings, followed by an error code
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int table_tcpreceive(lua_State *L)
2000-06-02 19:55:14 +02:00
{
static const char *const modenames[] = {"*l", "*lu", "*a", NULL};
const char *mode;
int err = NET_DONE;
int arg;
p_sock sock = pop_sock(L);
int top = lua_gettop(L);
tm_markstart(sock);
/* push default pattern if need be */
if (top < 2) {
lua_pushstring(L, "*l");
top++;
}
/* make sure we have enough stack space */
luaL_checkstack(L, top+LUA_MINSTACK, "too many arguments");
/* receive all patterns */
for (arg = 2; arg <= top; arg++) {
/* if one pattern fails, we just skip all other patterns */
if (err != NET_DONE) {
lua_pushnil(L);
continue;
}
if (lua_isnumber(L, arg)) {
int size = (int) lua_tonumber(L, arg);
err = receive_raw(L, sock, size);
} else {
mode = luaL_opt_string(L, arg, NULL);
/* get next pattern */
switch (luaL_findstring(mode, modenames)) {
/* DOS line mode */
case 0:
err = receive_dosline(L, sock);
break;
/* Unix line mode */
case 1:
err = receive_unixline(L, sock);
break;
/* until closed mode */
case 2:
err = receive_all(L, sock);
break;
/* else it is an error */
default:
luaL_arg_check(L, 0, arg, "invalid receive pattern");
break;
}
}
}
/* last return is an error code */
push_error(L, err);
2000-06-02 19:55:14 +02:00
#ifdef _DEBUG
/* push time elapsed during operation as the last return value */
lua_pushnumber(L, (sock->tm_end - sock->tm_start)/1000.0);
2000-06-02 19:55:14 +02:00
#endif
return lua_gettop(L) - top;
}
/*-------------------------------------------------------------------------*\
* Retrieves socket peer name
* Lua Input: sock
* sock: socket
* Lua Returns
* On success: ip address and port of peer
* On error: nil
\*-------------------------------------------------------------------------*/
static int table_getpeername(lua_State *L)
{
p_sock sock = pop_sock(L);
struct sockaddr_in peer;
size_t peer_len = sizeof(peer);
if (getpeername(sock->sock, (SA *) &peer, &peer_len) < 0) {
lua_pushnil(L);
return 1;
}
lua_pushstring(L, inet_ntoa(peer.sin_addr));
lua_pushnumber(L, ntohs(peer.sin_port));
return 2;
}
/*-------------------------------------------------------------------------*\
* Retrieves socket local name
* Lua Input: sock
* sock: socket
* Lua Returns
* On success: local ip address and port
* On error: nil
\*-------------------------------------------------------------------------*/
static int table_getsockname(lua_State *L)
{
p_sock sock = pop_sock(L);
struct sockaddr_in local;
size_t local_len = sizeof(local);
if (getsockname(sock->sock, (SA *) &local, &local_len) < 0) {
lua_pushnil(L);
return 1;
}
lua_pushstring(L, inet_ntoa(local.sin_addr));
lua_pushnumber(L, ntohs(local.sin_port));
return 2;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Closes a socket.
* Lua Input
2000-06-02 19:55:14 +02:00
* sock: socket to be closed
\*-------------------------------------------------------------------------*/
static int table_close(lua_State *L)
2000-06-02 19:55:14 +02:00
{
/* close socket and set value to INVALID_SOCKET so that
** pop_sock can later detect the use of a closed socket */
p_sock sock = (p_sock) lua_touserdata(L, -1);
if (!sock) lua_error(L, "invalid socket object");
if (sock->sock != INVALID_SOCKET) closesocket(sock->sock);
sock->sock = INVALID_SOCKET;
return 0;
}
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Garbage collection fallback for the socket objects. This function
* makes sure that all collected sockets are closed.
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int gc_table(lua_State *L)
2000-06-02 19:55:14 +02:00
{
p_tags tags = pop_tags(L);
p_sock sock = get_selfsock(L, tags, NULL);
/* sock might have been closed before */
if (sock->sock != INVALID_SOCKET) {
closesocket(sock->sock);
sock->sock = INVALID_SOCKET;
}
return 0;
2000-06-02 19:55:14 +02:00
}
/*=========================================================================*\
* Internal functions
\*=========================================================================*/
/*-------------------------------------------------------------------------*\
* Instals a handler to ignore sigpipe. That is, unless the signal had
* already been redefined. This function is not needed on the WinSock2,
* since it's sockets don't raise this signal.
\*-------------------------------------------------------------------------*/
#ifndef WIN32
static void handle_sigpipe(void);
static void handle_sigpipe(void)
{
struct sigaction new;
memset(&new, 0, sizeof(new));
new.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &new, NULL);
2000-06-02 19:55:14 +02:00
}
#endif
/*-------------------------------------------------------------------------*\
* Tries to create a TCP socket and connect to remote address (address, port)
* Input
* address: host name or ip address
* port: port number to bind to
2000-06-02 19:55:14 +02:00
* Returns
* NULL in case of success, error message otherwise
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
const char *tcp_tryconnect(p_sock sock, const char *address,
unsigned short port)
2000-06-02 19:55:14 +02:00
{
struct sockaddr_in remote;
memset(&remote, 0, sizeof(remote));
if (inet_aton(address, &remote.sin_addr)) {
remote.sin_family = AF_INET;
remote.sin_port = htons(port);
sock->sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock->sock == INVALID_SOCKET) return socket_strerror();
if (connect(sock->sock, (SA *) &remote, sizeof(remote)) < 0) {
closesocket(sock->sock);
sock->sock = INVALID_SOCKET;
return connect_strerror();
}
/* go ahead and try by hostname resolution */
} else {
struct hostent *hp = gethostbyname(address);
struct in_addr **addr;
if (!hp) return host_strerror();
addr = (struct in_addr **) hp->h_addr_list;
for (; *addr != NULL; addr++) {
memcpy(&remote.sin_addr, *addr, sizeof(struct in_addr));
remote.sin_family = AF_INET;
remote.sin_port = htons(port);
sock->sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock->sock == INVALID_SOCKET) return socket_strerror();
if (connect(sock->sock, (SA *) &remote, sizeof(remote)) == 0)
break;
closesocket(sock->sock);
sock->sock = INVALID_SOCKET;
memset(&remote, 0, sizeof(remote));
}
}
if (sock->sock == INVALID_SOCKET) return connect_strerror();
return NULL;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Sets the SO_REUSEADDR socket option
* Input
* sock: socket to set option
\*-------------------------------------------------------------------------*/
void set_reuseaddr(p_sock sock)
{
int val = 1;
setsockopt(sock->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Tries to create a TCP socket and bind it to (address, port)
2000-06-02 19:55:14 +02:00
* Input
* address: host name or ip address
* port: port number to bind to
* backlog: backlog to set
2000-06-02 19:55:14 +02:00
* Returns
* NULL in case of success, error message otherwise
\*-------------------------------------------------------------------------*/
const char *tcp_trybind(p_sock sock, const char *address,
unsigned short port, int backlog)
{
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_port = htons(port);
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY);
sock->sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock->sock == INVALID_SOCKET) return socket_strerror();
set_reuseaddr(sock);
/* address is either wildcard or a valid ip address */
if (!strcmp(address, "*") || inet_aton(address, &local.sin_addr)) {
if (bind(sock->sock, (SA *) &local, sizeof(local)) < 0) {
closesocket(sock->sock);
sock->sock = INVALID_SOCKET;
return bind_strerror();
}
/* otherwise, proceed with domain name resolution */
} else {
struct hostent *hp = gethostbyname(address);
struct in_addr **addr;
if (!hp) return host_strerror();
addr = (struct in_addr **) hp->h_addr_list;
for (; *addr != NULL; addr++) {
memcpy(&local.sin_addr, *addr, sizeof(struct in_addr));
if (bind(sock->sock, (SA *) &local, sizeof(local)) < 0) {
closesocket(sock->sock);
sock->sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock->sock == INVALID_SOCKET) return socket_strerror();
set_reuseaddr(sock);
} else break;
}
if (*addr == NULL) return bind_strerror();
}
/* set connection queue length */
if (listen(sock->sock, backlog) < 0) {
closesocket(sock->sock);
sock->sock = INVALID_SOCKET;
return "listen error";
}
/* no errors found */
return NULL;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Tries to bind the UDP socket to (address, port)
* Input
* address: host name or ip address
* port: port number to bind to
* Returns
* NULL in case of success, error message otherwise
\*-------------------------------------------------------------------------*/
const char *udp_setsockname(p_sock sock, const char *address,
unsigned short port)
{
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_port = htons(port);
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY);
set_reuseaddr(sock);
/* address is either wildcard or a valid ip address */
if (!strcmp(address, "*") || inet_aton(address, &local.sin_addr)) {
if (bind(sock->sock, (SA *) &local, sizeof(local)) < 0) {
closesocket(sock->sock);
sock->sock = INVALID_SOCKET;
return bind_strerror();
}
/* otherwise, proceed with domain name resolution */
} else {
struct hostent *hp = gethostbyname(address);
struct in_addr **addr;
if (!hp) return host_strerror();
addr = (struct in_addr **) hp->h_addr_list;
for (; *addr != NULL; addr++) {
memcpy(&local.sin_addr, *addr, sizeof(struct in_addr));
if (bind(sock->sock, (SA *) &local, sizeof(local)) < 0) {
closesocket(sock->sock);
sock->sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock->sock == INVALID_SOCKET) return socket_strerror();
set_reuseaddr(sock);
} else break;
}
if (*addr == NULL) return bind_strerror();
}
/* no errors found */
return NULL;
}
/*-------------------------------------------------------------------------*\
* Tries to connect a UDP to remote address (address, port)
* Input
* address: host name or ip address
* port: port number to bind to
* Returns
* NULL in case of success, error message otherwise
\*-------------------------------------------------------------------------*/
const char *udp_setpeername(p_sock sock, const char *address,
unsigned short port)
{
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_port = htons(port);
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY);
/* address is a valid ip address */
if (inet_aton(address, &local.sin_addr)) {
if (connect(sock->sock, (SA *) &local, sizeof(local)) < 0) {
closesocket(sock->sock);
sock->sock = INVALID_SOCKET;
return connect_strerror();
}
/* otherwise, proceed with domain name resolution */
} else {
struct hostent *hp = gethostbyname(address);
struct in_addr **addr;
if (!hp) return host_strerror();
addr = (struct in_addr **) hp->h_addr_list;
for (; *addr != NULL; addr++) {
memcpy(&local.sin_addr, *addr, sizeof(struct in_addr));
if (connect(sock->sock, (SA *) &local, sizeof(local)) < 0) {
closesocket(sock->sock);
sock->sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock->sock == INVALID_SOCKET) return socket_strerror();
} else break;
}
if (*addr == NULL) return connect_strerror();
}
/* no errors found */
return NULL;
}
/*=========================================================================*\
* Timeout management functions
\*=========================================================================*/
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Determines how much time we have left for the current io operation
* an IO write operation.
2000-06-02 19:55:14 +02:00
* Input
* sock: socket structure being used in operation
* Returns
* the number of ms left or -1 if there is no time limit
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int tm_gettimeleft(p_sock sock)
2000-06-02 19:55:14 +02:00
{
/* no timeout */
if (sock->tm_block < 0 && sock->tm_return < 0)
return -1;
/* there is no block timeout, we use the return timeout */
else if (sock->tm_block < 0)
return MAX(sock->tm_return - tm_gettime() + sock->tm_start, 0);
/* there is no return timeout, we use the block timeout */
else if (sock->tm_return < 0)
return sock->tm_block;
/* both timeouts are specified */
else return MIN(sock->tm_block,
MAX(sock->tm_return - tm_gettime() + sock->tm_start, 0));
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Determines if we have a timeout condition or if we can proceed with
* an IO operation.
2000-06-02 19:55:14 +02:00
* Input
* sock: socket structure being used in operation
* mode: TM_RECEIVE or TM_SEND
2000-06-02 19:55:14 +02:00
* Returns
* 1 if we can proceed, 0 if a timeout has occured
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int tm_timedout(p_sock sock, int mode)
2000-06-02 19:55:14 +02:00
{
fd_set fds;
int ret;
fd_set *preadfds = NULL, *pwritefds = NULL;
struct timeval tm;
struct timeval *ptm = NULL;
/* find out how much time we have left, in ms */
int ms = tm_gettimeleft(sock);
/* fill file descriptor set */
FD_ZERO(&fds); FD_SET(sock->sock, &fds);
/* fill timeval structure */
tm.tv_sec = ms / 1000;
tm.tv_usec = (ms % 1000) * 1000;
/* define function parameters */
if (ms >= 0) ptm = &tm; /* ptm == NULL when we don't have timeout */
if (mode == TM_RECEIVE) preadfds = &fds;
else pwritefds = &fds;
/* see if we can read, write or if we timedout */
ret = select(sock->sock+1, preadfds, pwritefds, NULL, ptm);
#ifdef _DEBUG
/* store end time for this operation next call to OS */
sock->tm_end = tm_gettime();
#endif
return ret <= 0;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Marks the operation start time in sock structure
* Input
* sock: socket structure being used in operation
\*-------------------------------------------------------------------------*/
static void tm_markstart(p_sock sock)
{
sock->tm_start = tm_gettime();
#ifdef _DEBUG
sock->tm_end = sock->tm_start;
#endif
}
/*-------------------------------------------------------------------------*\
* Gets time in ms, relative to system startup.
* Returns
* time in ms.
\*-------------------------------------------------------------------------*/
static int tm_gettime(void)
{
#ifdef WIN32
return GetTickCount();
#else
struct tms t;
return (times(&t)*1000)/CLK_TCK;
#endif
}
/*=========================================================================*\
* Buffered I/O management functions
\*=========================================================================*/
/*-------------------------------------------------------------------------*\
* Determines of there is any data in the read buffer
2000-06-02 19:55:14 +02:00
* Input
* sock: socket structure being used in operation
* Returns
* 1 if empty, 0 if there is data
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int bf_isempty(p_sock sock)
2000-06-02 19:55:14 +02:00
{
return sock->bf_first >= sock->bf_last;
}
/*-------------------------------------------------------------------------*\
* Skip a given number of bytes in read buffer
* Input
* sock: socket structure being used in operation
* length: number of bytes to skip
\*-------------------------------------------------------------------------*/
static void bf_skip(p_sock sock, int length)
{
sock->bf_first += length;
if (bf_isempty(sock)) sock->bf_first = sock->bf_last = 0;
}
/*-------------------------------------------------------------------------*\
* Return any data avilable in buffer, or get more data from transport layer
* if buffer is empty.
* Input
* sock: socket structure being used in operation
* Output
* length: number of bytes available in buffer
* Returns
* pointer to start of data
\*-------------------------------------------------------------------------*/
static const unsigned char *bf_receive(p_sock sock, int *length)
{
if (bf_isempty(sock)) {
int got = recv(sock->sock, sock->bf_buffer, LUASOCKET_TCPBUFFERSIZE, 0);
sock->bf_first = 0;
if (got >= 0) sock->bf_last = got;
else sock->bf_last = 0;
}
*length = sock->bf_last - sock->bf_first;
return sock->bf_buffer + sock->bf_first;
}
/*=========================================================================*\
* These are the function that are called for each I/O pattern
* The read patterns leave their result on the Lua stack
\*=========================================================================*/
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Sends a raw block of data through a socket. The operations are all
* non-blocking and the function respects the timeout values in sock.
* Input
* sock: socket structure being used in operation
* data: buffer to be sent
* wanted: number of bytes in buffer
* Output
* total: Number of bytes written
2000-06-02 19:55:14 +02:00
* Returns
* operation error code. NET_DONE, NET_TIMEOUT or NET_CLOSED
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int send_raw(p_sock sock, const char *data, int wanted, int *total)
2000-06-02 19:55:14 +02:00
{
int put = 0;
*total = 0;
while (wanted > 0) {
if (tm_timedout(sock, TM_SEND)) return NET_TIMEOUT;
put = send(sock->sock, data, wanted, 0);
if (put <= 0) {
#ifdef WIN32
/* a bug in WinSock forces us to do a busy wait until we manage
** to write, because select returns immediately even though it
** should have blocked us until we could write... */
if (put < 0 && WSAGetLastError() == WSAEWOULDBLOCK)
continue;
#endif
#ifdef __CYGWIN__
/* this is for CYGWIN, which is like Unix but with Win32 Bugs */
if (put < 0 && errno == EWOULDBLOCK)
continue;
#endif
return NET_CLOSED;
}
wanted -= put;
data += put;
*total += put;
}
return NET_DONE;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Reads a raw block of data from a socket. The operations are all
* non-blocking and the function respects the timeout values in sock.
* Input
* sock: socket structure being used in operation
* wanted: number of bytes to be read
* Returns
* operation error code. NET_DONE, NET_TIMEOUT or NET_CLOSED
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int receive_raw(lua_State *L, p_sock sock, int wanted)
2000-06-02 19:55:14 +02:00
{
int got = 0;
const unsigned char *buffer = NULL;
luaL_Buffer b;
luaL_buffinit(L, &b);
while (wanted > 0) {
if (bf_isempty(sock) && tm_timedout(sock, TM_RECEIVE)) {
luaL_pushresult(&b);
return NET_TIMEOUT;
}
buffer = bf_receive(sock, &got);
if (got <= 0) {
luaL_pushresult(&b);
return NET_CLOSED;
}
got = MIN(got, wanted);
luaL_addlstring(&b, buffer, got);
bf_skip(sock, got);
wanted -= got;
}
luaL_pushresult(&b);
return NET_DONE;
}
/*-------------------------------------------------------------------------*\
* Reads everything until the connection is closed
* Input
* sock: socket structure being used in operation
* Result
* operation error code. NET_DONE, NET_TIMEOUT
\*-------------------------------------------------------------------------*/
static int receive_all(lua_State *L, p_sock sock)
{
int got = 0;
const unsigned char *buffer = NULL;
luaL_Buffer b;
luaL_buffinit(L, &b);
for ( ;; ) {
if (bf_isempty(sock) && tm_timedout(sock, TM_RECEIVE)) {
luaL_pushresult(&b);
return NET_TIMEOUT;
}
buffer = bf_receive(sock, &got);
if (got <= 0) {
luaL_pushresult(&b);
return NET_DONE;
}
luaL_addlstring(&b, buffer, got);
bf_skip(sock, got);
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* 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 stream. All
* operations are non-blocking and the function respects the timeout
* values in sock.
2000-06-02 19:55:14 +02:00
* Input
* sock: socket structure being used in operation
* Result
* operation error code. NET_DONE, NET_TIMEOUT or NET_CLOSED
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int receive_dosline(lua_State *L, p_sock sock)
2000-06-02 19:55:14 +02:00
{
int got = 0;
const unsigned char *buffer = NULL;
luaL_Buffer b;
luaL_buffinit(L, &b);
for ( ;; ) {
if (bf_isempty(sock) && tm_timedout(sock, TM_RECEIVE)) {
luaL_pushresult(&b);
return NET_TIMEOUT;
}
buffer = bf_receive(sock, &got);
if (got > 0) {
int len = 0, end = 1;
while (len < got) {
if (buffer[len] == '\n') { /* found eol */
if (len > 0 && buffer[len-1] == '\r') {
end++; len--;
}
luaL_addlstring(&b, buffer, len);
bf_skip(sock, len + end); /* skip '\r\n' in stream */
luaL_pushresult(&b);
return NET_DONE;
}
len++;
}
luaL_addlstring(&b, buffer, got);
bf_skip(sock, got);
} else {
luaL_pushresult(&b);
return NET_CLOSED;
}
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Reads a line terminated by a LF character, which is not returned by
* the function, and is skipped in the stream. All operations are
* non-blocking and the function respects the timeout values in sock.
2000-06-02 19:55:14 +02:00
* Input
* sock: socket structure being used in operation
* Returns
* operation error code. NET_DONE, NET_TIMEOUT or NET_CLOSED
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
static int receive_unixline(lua_State *L, p_sock sock)
2000-06-02 19:55:14 +02:00
{
int got = 0;
const unsigned char *buffer = NULL;
luaL_Buffer b;
luaL_buffinit(L, &b);
for ( ;; ) {
if (bf_isempty(sock) && tm_timedout(sock, TM_RECEIVE)) {
luaL_pushresult(&b);
return NET_TIMEOUT;
}
buffer = bf_receive(sock, &got);
if (got > 0) {
int len = 0;
while (len < got) {
if (buffer[len] == '\n') { /* found eol */
luaL_addlstring(&b, buffer, len);
bf_skip(sock, len + 1); /* skip '\n' in stream */
luaL_pushresult(&b);
return NET_DONE;
}
len++;
}
luaL_addlstring(&b, buffer, got);
bf_skip(sock, got);
} else {
luaL_pushresult(&b);
return NET_CLOSED;
}
}
2000-06-02 19:55:14 +02:00
}
/*=========================================================================*\
* Module exported functions
\*=========================================================================*/
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Initializes the library interface with Lua and the socket library.
* Defines the symbols exported to Lua.
2000-06-02 19:55:14 +02:00
\*-------------------------------------------------------------------------*/
void lua_socketlibopen(lua_State *L)
2000-06-02 19:55:14 +02:00
{
static struct luaL_reg funcs[] = {
{"bind", global_tcpbind},
{"connect", global_tcpconnect},
{"select", global_select},
{"toip", global_toip},
{"tohostname", global_tohostname},
{"udpsocket", global_udpsocket},
};
unsigned int i;
/* declare new Lua tags for used userdata values */
p_tags tags = (p_tags) lua_newuserdata(L, sizeof(t_tags));
if (!tags) lua_error(L, "out of memory");
tags->client = lua_newtag(L);
tags->server = lua_newtag(L);
tags->table = lua_newtag(L);
tags->udp = lua_newtag(L);
/* global functions exported */
for (i = 0; i < sizeof(funcs)/sizeof(funcs[0]); i++) {
lua_pushuserdata(L, tags);
lua_pushcclosure(L, funcs[i].func, 1);
lua_setglobal(L, funcs[i].name);
}
/* socket garbage collection */
lua_pushuserdata(L, tags);
lua_pushcclosure(L, gc_table, 1);
lua_settagmethod(L, tags->table, "gc");
#ifdef WIN32
/* WinSock needs special initialization */
winsock_open();
#else
/* avoid getting killed by a SIGPIPE signal thrown by send */
handle_sigpipe();
#endif
#ifdef _DEBUG
/* test support functions */
lua_pushcfunction(L, global_sleep); lua_setglobal(L, "sleep");
lua_pushcfunction(L, global_time); lua_setglobal(L, "time");
#endif
}
/*=========================================================================*\
* Lua Stack manipulation functions
\*=========================================================================*/
/*-------------------------------------------------------------------------*\
* Creates a t_sock structure with default values for a client sock.
* Pushes the Lua table with sock fields and appropriate methods
* Input
* tags: tags structure
* Returns
* pointer to allocated t_sock structure, NULL in case of error
\*-------------------------------------------------------------------------*/
static p_sock push_clienttable(lua_State *L, p_tags tags)
{
static struct luaL_reg funcs[] = {
{"close", table_close},
{"getsockname", table_getsockname},
{"getpeername", table_getpeername},
{"receive", table_tcpreceive},
{"send", table_tcpsend},
{"timeout", table_timeout},
};
unsigned int i;
p_sock sock;
lua_newtable(L); lua_settag(L, tags->table);
lua_pushstring(L, P_SOCK);
sock = (p_sock) lua_newuserdata(L, sizeof(t_sock));
if (!sock) return NULL;
lua_settag(L, tags->client);
lua_settable(L, -3);
sock->sock = -1;
sock->is_connected = 0;
sock->tm_block = -1;
sock->tm_return = -1;
sock->bf_first = sock->bf_last = 0;
for (i = 0; i < sizeof(funcs)/sizeof(funcs[0]); i++) {
lua_pushstring(L, funcs[i].name);
lua_pushusertag(L, sock, tags->client);
lua_pushcclosure(L, funcs[i].func, 1);
lua_settable(L, -3);
}
return sock;
}
/*-------------------------------------------------------------------------*\
* Creates a t_sock structure with default values for a server sock.
* Pushes the Lua table with sock fields and appropriate methods
* Input
* tags: tags structure
* Returns
* pointer to allocated t_sock structure, NULL in case of error
\*-------------------------------------------------------------------------*/
static p_sock push_servertable(lua_State *L, p_tags tags)
{
static struct luaL_reg funcs[] = {
{"close", table_close},
{"getsockname", table_getsockname},
{"timeout", table_timeout},
};
unsigned int i;
p_sock sock;
lua_newtable(L); lua_settag(L, tags->table);
lua_pushstring(L, P_SOCK);
sock = (p_sock) lua_newuserdata(L, sizeof(t_sock));
if (!sock) return NULL;
lua_settag(L, tags->server);
lua_settable(L, -3);
sock->sock = INVALID_SOCKET;
sock->tm_block = -1;
sock->tm_return = -1;
sock->bf_first = sock->bf_last = 0;
for (i = 0; i < sizeof(funcs)/sizeof(funcs[0]); i++) {
lua_pushstring(L, funcs[i].name);
lua_pushusertag(L, sock, tags->client);
lua_pushcclosure(L, funcs[i].func, 1);
lua_settable(L, -3);
}
/* the accept method is different, it needs the tags closure too */
lua_pushstring(L, "accept");
lua_pushuserdata(L, tags);
lua_pushusertag(L, sock, tags->client);
lua_pushcclosure(L, table_tcpaccept, 2);
lua_settable(L, -3);
return sock;
}
/*-------------------------------------------------------------------------*\
* Creates a t_sock structure with default values for a udp sock.
* Pushes the Lua table with sock fields and appropriate methods
* Input
* tags: tags structure
* Returns
* pointer to allocated t_sock structure, NULL in case of error
\*-------------------------------------------------------------------------*/
static p_sock push_udptable(lua_State *L, p_tags tags)
{
static struct luaL_reg funcs[] = {
{"sendto", table_udpsendto},
{"setpeername", table_udpsetpeername},
{"setsockname", table_udpsetsockname},
{"getpeername", table_getpeername},
{"getsockname", table_getsockname},
{"receivefrom", table_udpreceivefrom},
{"receive", table_udpreceive},
{"send", table_udpsend},
{"close", table_close},
{"timeout", table_timeout},
};
unsigned int i;
p_sock sock;
lua_newtable(L); lua_settag(L, tags->table);
lua_pushstring(L, P_SOCK);
sock = (p_sock) lua_newuserdata(L, sizeof(t_sock));
if (!sock) {
lua_pushnil(L);
lua_pushstring(L, "out of memory");
return NULL;
}
lua_settag(L, tags->udp);
lua_settable(L, -3);
sock->sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock->sock == INVALID_SOCKET) {
lua_pushnil(L);
lua_pushstring(L, socket_strerror());
return NULL;
}
sock->is_connected = 0;
sock->tm_block = -1;
sock->tm_return = -1;
sock->bf_first = sock->bf_last = 0;
for (i = 0; i < sizeof(funcs)/sizeof(funcs[0]); i++) {
lua_pushstring(L, funcs[i].name);
lua_pushusertag(L, sock, tags->udp);
lua_pushcclosure(L, funcs[i].func, 1);
lua_settable(L, -3);
}
return sock;
}
/*-------------------------------------------------------------------------*\
* Passes all resolver information to Lua as a table
* Input
* hp: hostent structure returned by resolver
\*-------------------------------------------------------------------------*/
static void push_resolved(lua_State *L, struct hostent *hp)
{
char **alias;
struct in_addr **addr;
int i, resolved;
lua_newtable(L); resolved = lua_gettop(L);
lua_pushstring(L, "name");
lua_pushstring(L, hp->h_name);
lua_settable(L, resolved);
lua_pushstring(L, "ip");
lua_pushstring(L, "alias");
i = 1;
alias = hp->h_aliases;
lua_newtable(L);
while (*alias) {
lua_pushnumber(L, i);
lua_pushstring(L, *alias);
lua_settable(L, -3);
i++; alias++;
}
lua_settable(L, resolved);
i = 1;
lua_newtable(L);
addr = (struct in_addr **) hp->h_addr_list;
while (*addr) {
lua_pushnumber(L, i);
lua_pushstring(L, inet_ntoa(**addr));
lua_settable(L, -3);
i++; addr++;
}
lua_settable(L, resolved);
}
2000-06-02 19:55:14 +02:00
/*-------------------------------------------------------------------------*\
* Passes an error code to Lua. The NET_DONE error is translated to nil.
* Input
* err: error code to be passed to Lua
\*-------------------------------------------------------------------------*/
static void push_error(lua_State *L, int err)
{
switch (err) {
case NET_DONE:
lua_pushnil(L);
break;
case NET_TIMEOUT:
lua_pushstring(L, "timeout");
break;
case NET_CLOSED:
lua_pushstring(L, "closed");
break;
case NET_REFUSED:
lua_pushstring(L, "refused");
break;
}
2000-06-02 19:55:14 +02:00
}
static p_tags pop_tags(lua_State *L)
{
p_tags tags = (p_tags) lua_touserdata(L, -1);
if (!tags) lua_error(L, "invalid closure! (probably misuse of library)");
lua_pop(L, 1);
return tags;
}
static p_sock pop_sock(lua_State *L)
2000-06-02 19:55:14 +02:00
{
p_sock sock = (p_sock) lua_touserdata(L, -1);
if (!sock) lua_error(L, "invalid socket object");
if (sock->sock == INVALID_SOCKET)
lua_error(L, "operation on closed socket");
lua_pop(L, 1);
return sock;
2000-06-02 19:55:14 +02:00
}
static p_sock get_sock(lua_State *L, int s, p_tags tags, int *tag)
2000-06-02 19:55:14 +02:00
{
p_sock sock;
if (lua_tag(L, s) != tags->table) lua_error(L, "invalid socket object");
lua_pushstring(L, P_SOCK);
lua_gettable(L, s > 0 ? s : s-1);
sock = lua_touserdata(L, -1);
if (!sock) lua_error(L, "invalid socket object");
if (tag) *tag = lua_tag(L, -1);
lua_pop(L, 1);
return sock;
2000-06-02 19:55:14 +02:00
}
static p_sock get_selfsock(lua_State *L, p_tags tags, int *tag)
{
return get_sock(L, 1, tags, tag);
}
2000-06-02 19:55:14 +02:00
/*=========================================================================*\
* WinSock2 specific functions.
\*=========================================================================*/
#ifdef WIN32
/*-------------------------------------------------------------------------*\
* Initializes WinSock2 library.
* Returns
* 1 in case of success. 0 in case of error.
\*-------------------------------------------------------------------------*/
static int winsock_open(void)
2000-06-02 19:55:14 +02:00
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD(2, 0);
err = WSAStartup(wVersionRequested, &wsaData );
if (err != 0) {
return 0;
}
if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0) {
WSACleanup();
return 0;
}
return 1;
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Put socket into blocking mode.
\*-------------------------------------------------------------------------*/
static void set_blocking(p_sock sock)
{
u_long argp = 0;
ioctlsocket(sock->sock, FIONBIO, &argp);
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Put socket into non-blocking mode.
\*-------------------------------------------------------------------------*/
static void set_nonblocking(p_sock sock)
{
u_long argp = 1;
ioctlsocket(sock->sock, FIONBIO, &argp);
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Returns a string describing the last host manipulation error.
\*-------------------------------------------------------------------------*/
static char *host_strerror(void)
{
switch (WSAGetLastError()) {
case HOST_NOT_FOUND: return "host not found";
case NO_ADDRESS: return "unable to resolve host name";
case NO_RECOVERY: return "name server error";
case TRY_AGAIN: return "name server unavailable, try again later.";
default: return "unknown error";
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Returns a string describing the last socket manipulation error.
\*-------------------------------------------------------------------------*/
static char *socket_strerror(void)
2000-06-02 19:55:14 +02:00
{
switch (WSAGetLastError()) {
case WSANOTINITIALISED: return "not initialized";
case WSAENETDOWN: return "network is down";
case WSAEMFILE: return "descriptor table is full";
case WSAENOBUFS: return "insufficient buffer space";
default: return "unknown error";
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Returns a string describing the last bind operation error.
\*-------------------------------------------------------------------------*/
static char *bind_strerror(void)
{
switch (WSAGetLastError()) {
case WSANOTINITIALISED: return "not initialized";
case WSAENETDOWN: return "network is down";
case WSAEADDRINUSE: return "address already in use";
case WSAEINVAL: return "socket already bound";
case WSAENOBUFS: return "too many connections";
case WSAEFAULT: return "invalid address";
case WSAENOTSOCK: return "not a socket descriptor";
default: return "unknown error";
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Returns a string describing the last connect operationerror.
\*-------------------------------------------------------------------------*/
static char *connect_strerror(void)
{
switch (WSAGetLastError()) {
case WSANOTINITIALISED: return "not initialized";
case WSAENETDOWN: return "network is down";
case WSAEADDRINUSE: return "address already in use";
case WSAEADDRNOTAVAIL: return "address unavailable";
case WSAECONNREFUSED: return "connection refused";
case WSAENETUNREACH: return "network is unreachable";
default: return "unknown error";
}
2000-06-02 19:55:14 +02:00
}
#else
/*=========================================================================*\
* BSD specific functions.
\*=========================================================================*/
/*-------------------------------------------------------------------------*\
* Put socket into blocking mode.
\*-------------------------------------------------------------------------*/
static void set_blocking(p_sock sock)
{
int flags = fcntl(sock->sock, F_GETFL, 0);
flags &= (~(O_NONBLOCK));
fcntl(sock->sock, F_SETFL, flags);
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Put socket into non-blocking mode.
\*-------------------------------------------------------------------------*/
static void set_nonblocking(p_sock sock)
{
int flags = fcntl(sock->sock, F_GETFL, 0);
flags |= O_NONBLOCK;
fcntl(sock->sock, F_SETFL, flags);
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Returns a string describing the last host manipulation error.
\*-------------------------------------------------------------------------*/
static char *host_strerror(void)
{
switch (h_errno) {
case HOST_NOT_FOUND: return "host not found";
case NO_ADDRESS: return "unable to resolve host name";
case NO_RECOVERY: return "name server error";
case TRY_AGAIN: return "name server unavailable, try again later";
default: return "unknown error";
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Returns a string describing the last socket manipulation error.
\*-------------------------------------------------------------------------*/
static char *socket_strerror(void)
2000-06-02 19:55:14 +02:00
{
switch (errno) {
case EACCES: return "access denied";
case EMFILE: return "descriptor table is full";
case ENFILE: return "too many open files";
case ENOBUFS: return "insuffucient buffer space";
default: return "unknown error";
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Returns a string describing the last bind command error.
\*-------------------------------------------------------------------------*/
static char *bind_strerror(void)
{
switch (errno) {
case EBADF: return "invalid descriptor";
case EINVAL: return "socket already bound";
case EACCES: return "access denied";
case ENOTSOCK: return "not a socket descriptor";
case EADDRINUSE: return "address already in use";
case EADDRNOTAVAIL: return "address unavailable";
case ENOMEM: return "out of memory";
default: return "unknown error";
}
2000-06-02 19:55:14 +02:00
}
/*-------------------------------------------------------------------------*\
* Returns a string describing the last connect error.
\*-------------------------------------------------------------------------*/
static char *connect_strerror(void)
{
switch (errno) {
case EBADF: return "invalid descriptor";
case ENOTSOCK: return "not a socket descriptor";
case EADDRNOTAVAIL: return "address not availabe";
case ETIMEDOUT: return "connection timed out";
case ECONNREFUSED: return "connection refused";
case EACCES: return "access denied";
case ENETUNREACH: return "network is unreachable";
case EADDRINUSE: return "address already in use";
default: return "unknown error";
}
}
#endif
/*-------------------------------------------------------------------------*\
* Some systems do not provide this so that we provide our own. It's not
* marvelously fast, but it works just fine.
\*-------------------------------------------------------------------------*/
#ifdef LUASOCKET_ATON
static int inet_aton(const char *cp, struct in_addr *inp)
{
unsigned int a = 0, b = 0, c = 0, d = 0;
int n = 0, r;
unsigned long int addr = 0;
r = sscanf(cp, "%u.%u.%u.%u%n", &a, &b, &c, &d, &n);
if (r == 0 || n == 0) return 0;
cp += n;
if (*cp) return 0;
if (a > 255 || b > 255 || c > 255 || d > 255) return 0;
if (inp) {
addr += a; addr <<= 8;
addr += b; addr <<= 8;
addr += c; addr <<= 8;
addr += d;
inp->s_addr = htonl(addr);
}
return 1;
2000-06-02 19:55:14 +02:00
}
#endif