zyppe/luasocket
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Adjusted a few inconsistencies with the manual.

Browse source
This commit is contained in:
Diego Nehab 2003-08-16 00:06:04 +00:00
parent 3099704aff
commit c51d4acf1c
20 changed files with 412 additions and 156 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/ftp.lua
View file

@ -224,7 +224,7 @@ function Private.port(control)
local server, ctl_ip
ctl_ip, answer = control:getsockname()
server, answer = socket.bind(ctl_ip, 0)
server:timeout(Public.TIMEOUT)
server:settimeout(Public.TIMEOUT)
local ip, p, ph, pl
ip, p = server:getsockname()
pl = math.mod(p, 256)
@ -404,7 +404,7 @@ function Private.open(parsed)
local control, err = socket.connect(parsed.host, parsed.port)
if not control then return nil, err end
-- make sure we don't block forever
control:timeout(Public.TIMEOUT)
control:settimeout(Public.TIMEOUT)
-- check greeting
local code, answer = Private.greet(control)
if not code then return nil, answer end

2
src/http.lua
View file

@ -553,7 +553,7 @@ function Public.request_cb(request, response)
sock, response.error = socket.connect(parsed.host, parsed.port)
if not sock then return response end
-- set connection timeout so that we do not hang forever
sock:timeout(Public.TIMEOUT)
sock:settimeout(Public.TIMEOUT)
-- send request message
response.error = Private.send_request(sock, request.method,
Private.request_uri(parsed), request.headers, request.body_cb)

29
src/inet.c
View file

@ -20,6 +20,7 @@ static int inet_global_toip(lua_State *L);
static int inet_global_tohostname(lua_State *L);
static void inet_pushresolved(lua_State *L, struct hostent *hp);
/* DNS functions */
static luaL_reg func[] = {
{ "toip", inet_global_toip },
{ "tohostname", inet_global_tohostname },
@ -34,7 +35,19 @@ static luaL_reg func[] = {
\*-------------------------------------------------------------------------*/
void inet_open(lua_State *L)
{
luaL_openlib(L, LUASOCKET_LIBNAME, func, 0);
lua_pushstring(L, LUASOCKET_LIBNAME);
lua_gettable(L, LUA_GLOBALSINDEX);
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
lua_newtable(L);
lua_pushstring(L, LUASOCKET_LIBNAME);
lua_pushvalue(L, -2);
lua_settable(L, LUA_GLOBALSINDEX);
}
lua_pushstring(L, "dns");
lua_newtable(L);
luaL_openlib(L, NULL, func, 0);
lua_settable(L, -3);
lua_pop(L, 1);
}
@ -100,10 +113,11 @@ int inet_meth_getpeername(lua_State *L, p_sock ps)
socklen_t peer_len = sizeof(peer);
if (getpeername(*ps, (SA *) &peer, &peer_len) < 0) {
lua_pushnil(L);
return 1;
lua_pushstring(L, "getpeername failed");
} else {
lua_pushstring(L, inet_ntoa(peer.sin_addr));
lua_pushnumber(L, ntohs(peer.sin_port));
}
lua_pushstring(L, inet_ntoa(peer.sin_addr));
lua_pushnumber(L, ntohs(peer.sin_port));
return 2;
}
@ -116,10 +130,11 @@ int inet_meth_getsockname(lua_State *L, p_sock ps)
socklen_t local_len = sizeof(local);
if (getsockname(*ps, (SA *) &local, &local_len) < 0) {
lua_pushnil(L);
return 1;
lua_pushstring(L, "getsockname failed");
} else {
lua_pushstring(L, inet_ntoa(local.sin_addr));
lua_pushnumber(L, ntohs(local.sin_port));
}
lua_pushstring(L, inet_ntoa(local.sin_addr));
lua_pushnumber(L, ntohs(local.sin_port));
return 2;
}

12
src/smtp.lua
View file

@ -243,7 +243,7 @@ function Private.open(server)
-- connect to server and make sure we won't hang
local sock, err = socket.connect(server, Public.PORT)
if not sock then return nil, err end
sock:timeout(Public.TIMEOUT)
sock:settimeout(Public.TIMEOUT)
-- initial server greeting
code, answer = Private.check_answer(sock, 220)
if not code then return nil, answer end
@ -305,10 +305,10 @@ end
-----------------------------------------------------------------------------
function Public.mail(message)
local sock, err = Private.open(message.server)
if not sock then return err end
if not sock then return nil, err end
local code, answer = Private.send(sock, message)
if not code then return answer end
code, answer = Private.close(sock)
if code then return nil end
return answer
if not code then return nil, answer end
code, answer = Private.close(sock)
if code then return 1
else return nil, answer end
end

182
src/tcp.c
View file

@ -29,10 +29,10 @@ static int meth_receive(lua_State *L);
static int meth_accept(lua_State *L);
static int meth_close(lua_State *L);
static int meth_setoption(lua_State *L);
static int meth_timeout(lua_State *L);
static int meth_settimeout(lua_State *L);
static int meth_fd(lua_State *L);
static int meth_dirty(lua_State *L);
static int opt_nodelay(lua_State *L);
static int opt_tcp_nodelay(lua_State *L);
static int opt_keepalive(lua_State *L);
static int opt_linger(lua_State *L);
@ -47,7 +47,7 @@ static luaL_reg tcp[] = {
{"setsockname", meth_bind},
{"getpeername", meth_getpeername},
{"getsockname", meth_getsockname},
{"timeout", meth_timeout},
{"settimeout", meth_settimeout},
{"close", meth_close},
{"setoption", meth_setoption},
{"__gc", meth_close},
@ -59,7 +59,7 @@ static luaL_reg tcp[] = {
/* socket option handlers */
static luaL_reg opt[] = {
{"keepalive", opt_keepalive},
{"nodelay", opt_nodelay},
{"tcp-nodelay", opt_tcp_nodelay},
{"linger", opt_linger},
{NULL, NULL}
};
@ -83,8 +83,8 @@ void tcp_open(lua_State *L)
aux_add2group(L, "tcp{master}", "tcp{any}");
aux_add2group(L, "tcp{client}", "tcp{any}");
aux_add2group(L, "tcp{server}", "tcp{any}");
aux_add2group(L, "tcp{client}", "tcp{client, server}");
aux_add2group(L, "tcp{server}", "tcp{client, server}");
aux_add2group(L, "tcp{client}", "tcp{client,server}");
aux_add2group(L, "tcp{server}", "tcp{client,server}");
/* both server and client objects are selectable */
aux_add2group(L, "tcp{client}", "select{able}");
aux_add2group(L, "tcp{server}", "select{able}");
@ -121,7 +121,7 @@ static int meth_setoption(lua_State *L)
static int opt_boolean(lua_State *L, int level, int name)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{any}", 1);
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{client,server}", 1);
int val = aux_checkboolean(L, 2);
if (setsockopt(tcp->sock, level, name, (char *) &val, sizeof(val)) < 0) {
lua_pushnil(L);
@ -132,8 +132,8 @@ static int opt_boolean(lua_State *L, int level, int name)
return 1;
}
/* disables the Nagle algorithm */
static int opt_nodelay(lua_State *L)
/* disables the Naggle algorithm */
static int opt_tcp_nodelay(lua_State *L)
{
struct protoent *pe = getprotobyname("TCP");
if (!pe) {
@ -155,13 +155,13 @@ int opt_linger(lua_State *L)
struct linger li;
if (!lua_istable(L, 2))
luaL_typerror(L, 2, lua_typename(L, LUA_TTABLE));
lua_pushstring(L, "onoff");
lua_pushstring(L, "on");
lua_gettable(L, 2);
if (!lua_isnumber(L, -1)) luaL_argerror(L, 2, "invalid onoff field");
li.l_onoff = (int) lua_tonumber(L, -1);
lua_pushstring(L, "linger");
if (!lua_isboolean(L, -1)) luaL_argerror(L, 2, "invalid 'on' field");
li.l_onoff = lua_toboolean(L, -1);
lua_pushstring(L, "timeout");
lua_gettable(L, 2);
if (!lua_isnumber(L, -1)) luaL_argerror(L, 2, "invalid linger field");
if (!lua_isnumber(L, -1)) luaL_argerror(L, 2, "invalid 'timeout' field");
li.l_linger = (int) lua_tonumber(L, -1);
if (setsockopt(tcp->sock, SOL_SOCKET, SO_LINGER,
(char *) &li, sizeof(li) < 0)) {
@ -178,93 +178,18 @@ int opt_linger(lua_State *L)
\*-------------------------------------------------------------------------*/
static int meth_fd(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{client, server}", 1);
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{client,server}", 1);
lua_pushnumber(L, tcp->sock);
return 1;
}
static int meth_dirty(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{client, server}", 1);
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{client,server}", 1);
lua_pushboolean(L, !buf_isempty(&tcp->buf));
return 1;
}
/*-------------------------------------------------------------------------*\
* Just call inet methods
\*-------------------------------------------------------------------------*/
static int meth_getpeername(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkclass(L, "tcp{client}", 1);
return inet_meth_getpeername(L, &tcp->sock);
}
static int meth_getsockname(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{client, server}", 1);
return inet_meth_getsockname(L, &tcp->sock);
}
/*-------------------------------------------------------------------------*\
* Just call tm methods
\*-------------------------------------------------------------------------*/
static int meth_timeout(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{any}", 1);
return tm_meth_timeout(L, &tcp->tm);
}
/*-------------------------------------------------------------------------*\
* Closes socket used by object
\*-------------------------------------------------------------------------*/
static int meth_close(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{any}", 1);
sock_destroy(&tcp->sock);
return 0;
}
/*-------------------------------------------------------------------------*\
* Turns a master tcp object into a client object.
\*-------------------------------------------------------------------------*/
static int meth_connect(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkclass(L, "tcp{master}", 1);
const char *address = luaL_checkstring(L, 2);
unsigned short port = (unsigned short) luaL_checknumber(L, 3);
const char *err = inet_tryconnect(&tcp->sock, address, port);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
/* turn master object into a client object */
aux_setclass(L, "tcp{client}", 1);
lua_pushnumber(L, 1);
return 1;
}
/*-------------------------------------------------------------------------*\
* Turns a master object into a server object
\*-------------------------------------------------------------------------*/
static int meth_bind(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkclass(L, "tcp{master}", 1);
const char *address = luaL_checkstring(L, 2);
unsigned short port = (unsigned short) luaL_checknumber(L, 3);
int backlog = (int) luaL_optnumber(L, 4, 1);
const char *err = inet_trybind(&tcp->sock, address, port, backlog);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
/* turn master object into a server object */
aux_setclass(L, "tcp{server}", 1);
lua_pushnumber(L, 1);
return 1;
}
/*-------------------------------------------------------------------------*\
* Waits for and returns a client object attempting connection to the
* server object
@ -296,6 +221,81 @@ static int meth_accept(lua_State *L)
return 1;
}
/*-------------------------------------------------------------------------*\
* Turns a master object into a server object
\*-------------------------------------------------------------------------*/
static int meth_bind(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkclass(L, "tcp{master}", 1);
const char *address = luaL_checkstring(L, 2);
unsigned short port = (unsigned short) luaL_checknumber(L, 3);
int backlog = (int) luaL_optnumber(L, 4, 1);
const char *err = inet_trybind(&tcp->sock, address, port, backlog);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
/* turn master object into a server object */
aux_setclass(L, "tcp{server}", 1);
lua_pushnumber(L, 1);
return 1;
}
/*-------------------------------------------------------------------------*\
* Turns a master tcp object into a client object.
\*-------------------------------------------------------------------------*/
static int meth_connect(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkclass(L, "tcp{master}", 1);
const char *address = luaL_checkstring(L, 2);
unsigned short port = (unsigned short) luaL_checknumber(L, 3);
const char *err = inet_tryconnect(&tcp->sock, address, port);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
/* turn master object into a client object */
aux_setclass(L, "tcp{client}", 1);
lua_pushnumber(L, 1);
return 1;
}
/*-------------------------------------------------------------------------*\
* Closes socket used by object
\*-------------------------------------------------------------------------*/
static int meth_close(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{any}", 1);
sock_destroy(&tcp->sock);
return 0;
}
/*-------------------------------------------------------------------------*\
* Just call inet methods
\*-------------------------------------------------------------------------*/
static int meth_getpeername(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkclass(L, "tcp{client}", 1);
return inet_meth_getpeername(L, &tcp->sock);
}
static int meth_getsockname(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{client,server}", 1);
return inet_meth_getsockname(L, &tcp->sock);
}
/*-------------------------------------------------------------------------*\
* Just call tm methods
\*-------------------------------------------------------------------------*/
static int meth_settimeout(lua_State *L)
{
p_tcp tcp = (p_tcp) aux_checkgroup(L, "tcp{client,server}", 1);
return tm_meth_settimeout(L, &tcp->tm);
}
/*=========================================================================*\
* Library functions
\*=========================================================================*/

2
src/timeout.c
View file

@ -125,7 +125,7 @@ void tm_open(lua_State *L)
* time: time out value in seconds
* mode: "b" for block timeout, "t" for total timeout. (default: b)
\*-------------------------------------------------------------------------*/
int tm_meth_timeout(lua_State *L, p_tm tm)
int tm_meth_settimeout(lua_State *L, p_tm tm)
{
int ms = lua_isnil(L, 2) ? -1 : (int) (luaL_checknumber(L, 2)*1000.0);
const char *mode = luaL_optstring(L, 3, "b");

2
src/timeout.h
View file

@ -26,6 +26,6 @@ void tm_markstart(p_tm tm);
int tm_getstart(p_tm tm);
int tm_get(p_tm tm);
int tm_gettime(void);
int tm_meth_timeout(lua_State *L, p_tm tm);
int tm_meth_settimeout(lua_State *L, p_tm tm);
#endif /* TM_H */

10
src/udp.c
View file

@ -30,7 +30,7 @@ static int meth_setsockname(lua_State *L);
static int meth_setpeername(lua_State *L);
static int meth_close(lua_State *L);
static int meth_setoption(lua_State *L);
static int meth_timeout(lua_State *L);
static int meth_settimeout(lua_State *L);
static int meth_fd(lua_State *L);
static int meth_dirty(lua_State *L);
static int opt_dontroute(lua_State *L);
@ -46,7 +46,7 @@ static luaL_reg udp[] = {
{"sendto", meth_sendto},
{"receive", meth_receive},
{"receivefrom", meth_receivefrom},
{"timeout", meth_timeout},
{"settimeout", meth_settimeout},
{"close", meth_close},
{"setoption", meth_setoption},
{"__gc", meth_close},
@ -252,10 +252,10 @@ static int opt_broadcast(lua_State *L)
/*-------------------------------------------------------------------------*\
* Just call tm methods
\*-------------------------------------------------------------------------*/
static int meth_timeout(lua_State *L)
static int meth_settimeout(lua_State *L)
{
p_udp udp = (p_udp) aux_checkgroup(L, "udp{any}", 1);
return tm_meth_timeout(L, &udp->tm);
return tm_meth_settimeout(L, &udp->tm);
}
/*-------------------------------------------------------------------------*\
@ -297,7 +297,7 @@ static int meth_close(lua_State *L)
\*-------------------------------------------------------------------------*/
static int meth_setsockname(lua_State *L)
{
p_udp udp = (p_udp) aux_checkclass(L, "udp{master}", 1);
p_udp udp = (p_udp) aux_checkclass(L, "udp{unconnected}", 1);
const char *address = luaL_checkstring(L, 2);
unsigned short port = (unsigned short) luaL_checknumber(L, 3);
const char *err = inet_trybind(&udp->sock, address, port, -1);

6
src/usocket.c
View file

@ -26,8 +26,10 @@ int sock_open(void)
\*-------------------------------------------------------------------------*/
void sock_destroy(p_sock ps)
{
close(*ps);
*ps = SOCK_INVALID;
if (*ps != SOCK_INVALID) {
close(*ps);
*ps = SOCK_INVALID;
}
}
/*-------------------------------------------------------------------------*\

6
src/wsocket.c
View file

@ -29,8 +29,10 @@ int sock_open(void)
\*-------------------------------------------------------------------------*/
void sock_destroy(p_sock ps)
{
closesocket(*ps);
*ps = SOCK_INVALID;
if (*ps != SOCK_INVALID) {
closesocket(*ps);
*ps = SOCK_INVALID;
}
}
/*-------------------------------------------------------------------------*\