dany/luasocket
1
0
Fork 0
mirror of https://github.com/lunarmodules/luasocket.git synced 2024-11-16 02:08:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

rename unix.tcp to unix.stream, unix.udp to unix.dgram

Browse Source
This commit is contained in:
enginix 2016-12-25 23:15:12 +08:00
parent ac3201d620
commit 3a33c37b9c
11 changed files with 129 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/makefile
View File

@ -307,8 +307,8 @@ UNIX_OBJS=\
timeout.$(O) \
io.$(O) \
usocket.$(O) \
unixtcp.$(O) \
unixudp.$(O) \
unixstream.$(O) \
unixdgram.$(O) \
compat.$(O) \
unix.$(O)

8
src/unix.c
View File

@ -5,15 +5,15 @@
#include "lua.h"
#include "lauxlib.h"
#include "unixtcp.h"
#include "unixudp.h"
#include "unixstream.h"
#include "unixdgram.h"
/*-------------------------------------------------------------------------*\
* Modules and functions
\*-------------------------------------------------------------------------*/
static const luaL_Reg mod[] = {
{"tcp", unixtcp_open},
{"udp", unixudp_open},
{"stream", unixstream_open},
{"dgram", unixdgram_open},
{NULL, NULL}
};

96
src/unixudp.c → src/unixdgram.c
View File

@ -1,5 +1,5 @@
/*=========================================================================*\
* Unix domain socket udp submodule
* Unix domain socket dgram submodule
* LuaSocket toolkit
\*=========================================================================*/
#include <string.h>
@ -15,7 +15,7 @@
#include "unix.h"
#include <sys/un.h>
#define UNIXUDP_DATAGRAMSIZE 8192
#define UNIXDGRAM_DATAGRAMSIZE 8192
/*=========================================================================*\
* Internal function prototypes
@ -36,11 +36,11 @@ static int meth_receivefrom(lua_State *L);
static int meth_sendto(lua_State *L);
static int meth_getsockname(lua_State *L);
static const char *unixudp_tryconnect(p_unix un, const char *path);
static const char *unixudp_trybind(p_unix un, const char *path);
static const char *unixdgram_tryconnect(p_unix un, const char *path);
static const char *unixdgram_trybind(p_unix un, const char *path);
/* unixudp object methods */
static luaL_Reg unixudp_methods[] = {
/* unixdgram object methods */
static luaL_Reg unixdgram_methods[] = {
{"__gc", meth_close},
{"__tostring", auxiliar_tostring},
{"bind", meth_bind},
@ -70,23 +70,23 @@ static t_opt optset[] = {
/* functions in library namespace */
static luaL_Reg func[] = {
{"udp", global_create},
{"dgram", global_create},
{NULL, NULL}
};
/*-------------------------------------------------------------------------*\
* Initializes module
\*-------------------------------------------------------------------------*/
int unixudp_open(lua_State *L)
int unixdgram_open(lua_State *L)
{
/* create classes */
auxiliar_newclass(L, "unixudp{connected}", unixudp_methods);
auxiliar_newclass(L, "unixudp{unconnected}", unixudp_methods);
auxiliar_newclass(L, "unixdgram{connected}", unixdgram_methods);
auxiliar_newclass(L, "unixdgram{unconnected}", unixdgram_methods);
/* create class groups */
auxiliar_add2group(L, "unixudp{connected}", "unixudp{any}");
auxiliar_add2group(L, "unixudp{unconnected}", "unixudp{any}");
auxiliar_add2group(L, "unixudp{connected}", "select{able}");
auxiliar_add2group(L, "unixudp{unconnected}", "select{able}");
auxiliar_add2group(L, "unixdgram{connected}", "unixdgram{any}");
auxiliar_add2group(L, "unixdgram{unconnected}", "unixdgram{any}");
auxiliar_add2group(L, "unixdgram{connected}", "select{able}");
auxiliar_add2group(L, "unixdgram{unconnected}", "select{able}");
luaL_setfuncs(L, func, 0);
return 0;
@ -95,7 +95,7 @@ int unixudp_open(lua_State *L)
/*=========================================================================*\
* Lua methods
\*=========================================================================*/
static const char *unixudp_strerror(int err)
static const char *unixdgram_strerror(int err)
{
/* a 'closed' error on an unconnected means the target address was not
* accepted by the transport layer */
@ -105,7 +105,7 @@ static const char *unixudp_strerror(int err)
static int meth_send(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkclass(L, "unixudp{connected}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixdgram{connected}", 1);
p_timeout tm = &un->tm;
size_t count, sent = 0;
int err;
@ -114,7 +114,7 @@ static int meth_send(lua_State *L)
err = socket_send(&un->sock, data, count, &sent, tm);
if (err != IO_DONE) {
lua_pushnil(L);
lua_pushstring(L, unixudp_strerror(err));
lua_pushstring(L, unixdgram_strerror(err));
return 2;
}
lua_pushnumber(L, (lua_Number) sent);
@ -122,11 +122,11 @@ static int meth_send(lua_State *L)
}
/*-------------------------------------------------------------------------*\
* Send data through unconnected unixudp socket
* Send data through unconnected unixdgram socket
\*-------------------------------------------------------------------------*/
static int meth_sendto(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkclass(L, "unixudp{unconnected}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixdgram{unconnected}", 1);
size_t count, sent = 0;
const char *data = luaL_checklstring(L, 2, &count);
const char *path = luaL_checkstring(L, 3);
@ -155,7 +155,7 @@ static int meth_sendto(lua_State *L)
#endif
if (err != IO_DONE) {
lua_pushnil(L);
lua_pushstring(L, unixudp_strerror(err));
lua_pushstring(L, unixdgram_strerror(err));
return 2;
}
lua_pushnumber(L, (lua_Number) sent);
@ -163,8 +163,8 @@ static int meth_sendto(lua_State *L)
}
static int meth_receive(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
char buf[UNIXUDP_DATAGRAMSIZE];
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
char buf[UNIXDGRAM_DATAGRAMSIZE];
size_t got, wanted = (size_t) luaL_optnumber(L, 2, sizeof(buf));
char *dgram = wanted > sizeof(buf)? (char *) malloc(wanted): buf;
int err;
@ -176,10 +176,10 @@ static int meth_receive(lua_State *L) {
return 2;
}
err = socket_recv(&un->sock, dgram, wanted, &got, tm);
/* Unlike TCP, recv() of zero is not closed, but a zero-length packet. */
/* Unlike STREAM, recv() of zero is not closed, but a zero-length packet. */
if (err != IO_DONE && err != IO_CLOSED) {
lua_pushnil(L);
lua_pushstring(L, unixudp_strerror(err));
lua_pushstring(L, unixdgram_strerror(err));
if (wanted > sizeof(buf)) free(dgram);
return 2;
}
@ -189,11 +189,11 @@ static int meth_receive(lua_State *L) {
}
/*-------------------------------------------------------------------------*\
* Receives data and sender from a UDP socket
* Receives data and sender from a DGRAM socket
\*-------------------------------------------------------------------------*/
static int meth_receivefrom(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkclass(L, "unixudp{unconnected}", 1);
char buf[UNIXUDP_DATAGRAMSIZE];
p_unix un = (p_unix) auxiliar_checkclass(L, "unixdgram{unconnected}", 1);
char buf[UNIXDGRAM_DATAGRAMSIZE];
size_t got, wanted = (size_t) luaL_optnumber(L, 2, sizeof(buf));
char *dgram = wanted > sizeof(buf)? (char *) malloc(wanted): buf;
struct sockaddr_un addr;
@ -208,10 +208,10 @@ static int meth_receivefrom(lua_State *L) {
}
err = socket_recvfrom(&un->sock, dgram, wanted, &got, (SA *) &addr,
&addr_len, tm);
/* Unlike TCP, recv() of zero is not closed, but a zero-length packet. */
/* Unlike STREAM, recv() of zero is not closed, but a zero-length packet. */
if (err != IO_DONE && err != IO_CLOSED) {
lua_pushnil(L);
lua_pushstring(L, unixudp_strerror(err));
lua_pushstring(L, unixdgram_strerror(err));
if (wanted > sizeof(buf)) free(dgram);
return 2;
}
@ -227,7 +227,7 @@ static int meth_receivefrom(lua_State *L) {
* Just call option handler
\*-------------------------------------------------------------------------*/
static int meth_setoption(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
return opt_meth_setoption(L, optset, &un->sock);
}
@ -235,20 +235,20 @@ static int meth_setoption(lua_State *L) {
* Select support methods
\*-------------------------------------------------------------------------*/
static int meth_getfd(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
lua_pushnumber(L, (int) un->sock);
return 1;
}
/* this is very dangerous, but can be handy for those that are brave enough */
static int meth_setfd(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
un->sock = (t_socket) luaL_checknumber(L, 2);
return 0;
}
static int meth_dirty(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
(void) un;
lua_pushboolean(L, 0);
return 1;
@ -257,7 +257,7 @@ static int meth_dirty(lua_State *L) {
/*-------------------------------------------------------------------------*\
* Binds an object to an address
\*-------------------------------------------------------------------------*/
static const char *unixudp_trybind(p_unix un, const char *path) {
static const char *unixdgram_trybind(p_unix un, const char *path) {
struct sockaddr_un local;
size_t len = strlen(path);
int err;
@ -280,9 +280,9 @@ static const char *unixudp_trybind(p_unix un, const char *path) {
static int meth_bind(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkclass(L, "unixudp{unconnected}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixdgram{unconnected}", 1);
const char *path = luaL_checkstring(L, 2);
const char *err = unixudp_trybind(un, path);
const char *err = unixdgram_trybind(un, path);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
@ -294,7 +294,7 @@ static int meth_bind(lua_State *L)
static int meth_getsockname(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
struct sockaddr_un peer = {0};
socklen_t peer_len = sizeof(peer);
@ -309,9 +309,9 @@ static int meth_getsockname(lua_State *L)
}
/*-------------------------------------------------------------------------*\
* Turns a master unixudp object into a client object.
* Turns a master unixdgram object into a client object.
\*-------------------------------------------------------------------------*/
static const char *unixudp_tryconnect(p_unix un, const char *path)
static const char *unixdgram_tryconnect(p_unix un, const char *path)
{
struct sockaddr_un remote;
int err;
@ -335,16 +335,16 @@ static const char *unixudp_tryconnect(p_unix un, const char *path)
static int meth_connect(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
const char *path = luaL_checkstring(L, 2);
const char *err = unixudp_tryconnect(un, path);
const char *err = unixdgram_tryconnect(un, path);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
/* turn unconnected object into a connected object */
auxiliar_setclass(L, "unixudp{connected}", 1);
auxiliar_setclass(L, "unixdgram{connected}", 1);
lua_pushnumber(L, 1);
return 1;
}
@ -354,7 +354,7 @@ static int meth_connect(lua_State *L)
\*-------------------------------------------------------------------------*/
static int meth_close(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
socket_destroy(&un->sock);
lua_pushnumber(L, 1);
return 1;
@ -365,13 +365,13 @@ static int meth_close(lua_State *L)
\*-------------------------------------------------------------------------*/
static int meth_settimeout(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
return timeout_meth_settimeout(L, &un->tm);
}
static int meth_gettimeout(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixudp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixdgram{any}", 1);
return timeout_meth_gettimeout(L, &un->tm);
}
@ -379,7 +379,7 @@ static int meth_gettimeout(lua_State *L)
* Library functions
\*=========================================================================*/
/*-------------------------------------------------------------------------*\
* Creates a master unixudp object
* Creates a master unixdgram object
\*-------------------------------------------------------------------------*/
static int global_create(lua_State *L)
{
@ -387,10 +387,10 @@ static int global_create(lua_State *L)
int err = socket_create(&sock, AF_UNIX, SOCK_DGRAM, 0);
/* try to allocate a system socket */
if (err == IO_DONE) {
/* allocate unixudp object */
/* allocate unixdgram object */
p_unix un = (p_unix) lua_newuserdata(L, sizeof(t_unix));
/* set its type as master object */
auxiliar_setclass(L, "unixudp{unconnected}", -1);
auxiliar_setclass(L, "unixdgram{unconnected}", -1);
/* initialize remaining structure fields */
socket_setnonblocking(&sock);
un->sock = sock;

14
src/unixudp.h → src/unixdgram.h
View File

@ -1,13 +1,13 @@
#ifndef UNIXUDP_H
#define UNIXUDP_H
#ifndef UNIXDGRAM_H
#define UNIXDGRAM_H
/*=========================================================================*\
* UDP object
* DGRAM object
* LuaSocket toolkit
*
* The udp.h module provides LuaSocket with support for UDP protocol
* The dgram.h module provides LuaSocket with support for DGRAM protocol
* (AF_INET, SOCK_DGRAM).
*
* Two classes are defined: connected and unconnected. UDP objects are
* Two classes are defined: connected and unconnected. DGRAM objects are
* originally unconnected. They can be "connected" to a given address
* with a call to the setpeername function. The same function can be used to
* break the connection.
@ -15,6 +15,6 @@
#include "unix.h"
int unixudp_open(lua_State *L);
int unixdgram_open(lua_State *L);
#endif /* UNIXUDP_H */
#endif /* UNIXDGRAM_H */

84
src/unixtcp.c → src/unixstream.c
View File

@ -1,5 +1,5 @@
/*=========================================================================*\
* Unix domain socket tcp sub module
* Unix domain socket stream sub module
* LuaSocket toolkit
\*=========================================================================*/
#include <string.h>
@ -11,7 +11,7 @@
#include "auxiliar.h"
#include "socket.h"
#include "options.h"
#include "unixtcp.h"
#include "unixstream.h"
#include <sys/un.h>
/*=========================================================================*\
@ -35,11 +35,11 @@ static int meth_getstats(lua_State *L);
static int meth_setstats(lua_State *L);
static int meth_getsockname(lua_State *L);
static const char *unixtcp_tryconnect(p_unix un, const char *path);
static const char *unixtcp_trybind(p_unix un, const char *path);
static const char *unixstream_tryconnect(p_unix un, const char *path);
static const char *unixstream_trybind(p_unix un, const char *path);
/* unixtcp object methods */
static luaL_Reg unixtcp_methods[] = {
/* unixstream object methods */
static luaL_Reg unixstream_methods[] = {
{"__gc", meth_close},
{"__tostring", auxiliar_tostring},
{"accept", meth_accept},
@ -73,24 +73,24 @@ static t_opt optset[] = {
/* functions in library namespace */
static luaL_Reg func[] = {
{"tcp", global_create},
{"stream", global_create},
{NULL, NULL}
};
/*-------------------------------------------------------------------------*\
* Initializes module
\*-------------------------------------------------------------------------*/
int unixtcp_open(lua_State *L)
int unixstream_open(lua_State *L)
{
/* create classes */
auxiliar_newclass(L, "unixtcp{master}", unixtcp_methods);
auxiliar_newclass(L, "unixtcp{client}", unixtcp_methods);
auxiliar_newclass(L, "unixtcp{server}", unixtcp_methods);
auxiliar_newclass(L, "unixstream{master}", unixstream_methods);
auxiliar_newclass(L, "unixstream{client}", unixstream_methods);
auxiliar_newclass(L, "unixstream{server}", unixstream_methods);
/* create class groups */
auxiliar_add2group(L, "unixtcp{master}", "unixtcp{any}");
auxiliar_add2group(L, "unixtcp{client}", "unixtcp{any}");
auxiliar_add2group(L, "unixtcp{server}", "unixtcp{any}");
auxiliar_add2group(L, "unixstream{master}", "unixstream{any}");
auxiliar_add2group(L, "unixstream{client}", "unixstream{any}");
auxiliar_add2group(L, "unixstream{server}", "unixstream{any}");
luaL_setfuncs(L, func, 0);
return 0;
@ -103,22 +103,22 @@ int unixtcp_open(lua_State *L)
* Just call buffered IO methods
\*-------------------------------------------------------------------------*/
static int meth_send(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkclass(L, "unixtcp{client}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixstream{client}", 1);
return buffer_meth_send(L, &un->buf);
}
static int meth_receive(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkclass(L, "unixtcp{client}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixstream{client}", 1);
return buffer_meth_receive(L, &un->buf);
}
static int meth_getstats(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkclass(L, "unixtcp{client}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixstream{client}", 1);
return buffer_meth_getstats(L, &un->buf);
}
static int meth_setstats(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkclass(L, "unixtcp{client}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixstream{client}", 1);
return buffer_meth_setstats(L, &un->buf);
}
@ -126,7 +126,7 @@ static int meth_setstats(lua_State *L) {
* Just call option handler
\*-------------------------------------------------------------------------*/
static int meth_setoption(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixtcp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixstream{any}", 1);
return opt_meth_setoption(L, optset, &un->sock);
}
@ -134,20 +134,20 @@ static int meth_setoption(lua_State *L) {
* Select support methods
\*-------------------------------------------------------------------------*/
static int meth_getfd(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixtcp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixstream{any}", 1);
lua_pushnumber(L, (int) un->sock);
return 1;
}
/* this is very dangerous, but can be handy for those that are brave enough */
static int meth_setfd(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixtcp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixstream{any}", 1);
un->sock = (t_socket) luaL_checknumber(L, 2);
return 0;
}
static int meth_dirty(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixtcp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixstream{any}", 1);
lua_pushboolean(L, !buffer_isempty(&un->buf));
return 1;
}
@ -157,14 +157,14 @@ static int meth_dirty(lua_State *L) {
* server object
\*-------------------------------------------------------------------------*/
static int meth_accept(lua_State *L) {
p_unix server = (p_unix) auxiliar_checkclass(L, "unixtcp{server}", 1);
p_unix server = (p_unix) auxiliar_checkclass(L, "unixstream{server}", 1);
p_timeout tm = timeout_markstart(&server->tm);
t_socket sock;
int err = socket_accept(&server->sock, &sock, NULL, NULL, tm);
/* if successful, push client socket */
if (err == IO_DONE) {
p_unix clnt = (p_unix) lua_newuserdata(L, sizeof(t_unix));
auxiliar_setclass(L, "unixtcp{client}", -1);
auxiliar_setclass(L, "unixstream{client}", -1);
/* initialize structure fields */
socket_setnonblocking(&sock);
clnt->sock = sock;
@ -183,7 +183,7 @@ static int meth_accept(lua_State *L) {
/*-------------------------------------------------------------------------*\
* Binds an object to an address
\*-------------------------------------------------------------------------*/
static const char *unixtcp_trybind(p_unix un, const char *path) {
static const char *unixstream_trybind(p_unix un, const char *path) {
struct sockaddr_un local;
size_t len = strlen(path);
int err;
@ -205,9 +205,9 @@ static const char *unixtcp_trybind(p_unix un, const char *path) {
}
static int meth_bind(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkclass(L, "unixtcp{master}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixstream{master}", 1);
const char *path = luaL_checkstring(L, 2);
const char *err = unixtcp_trybind(un, path);
const char *err = unixstream_trybind(un, path);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
@ -219,7 +219,7 @@ static int meth_bind(lua_State *L) {
static int meth_getsockname(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixtcp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixstream{any}", 1);
struct sockaddr_un peer = {0};
socklen_t peer_len = sizeof(peer);
@ -234,9 +234,9 @@ static int meth_getsockname(lua_State *L)
}
/*-------------------------------------------------------------------------*\
* Turns a master unixtcp object into a client object.
* Turns a master unixstream object into a client object.
\*-------------------------------------------------------------------------*/
static const char *unixtcp_tryconnect(p_unix un, const char *path)
static const char *unixstream_tryconnect(p_unix un, const char *path)
{
struct sockaddr_un remote;
int err;
@ -260,16 +260,16 @@ static const char *unixtcp_tryconnect(p_unix un, const char *path)
static int meth_connect(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkclass(L, "unixtcp{master}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixstream{master}", 1);
const char *path = luaL_checkstring(L, 2);
const char *err = unixtcp_tryconnect(un, path);
const char *err = unixstream_tryconnect(un, path);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
/* turn master object into a client object */
auxiliar_setclass(L, "unixtcp{client}", 1);
auxiliar_setclass(L, "unixstream{client}", 1);
lua_pushnumber(L, 1);
return 1;
}
@ -279,7 +279,7 @@ static int meth_connect(lua_State *L)
\*-------------------------------------------------------------------------*/
static int meth_close(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixtcp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixstream{any}", 1);
socket_destroy(&un->sock);
lua_pushnumber(L, 1);
return 1;
@ -290,7 +290,7 @@ static int meth_close(lua_State *L)
\*-------------------------------------------------------------------------*/
static int meth_listen(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkclass(L, "unixtcp{master}", 1);
p_unix un = (p_unix) auxiliar_checkclass(L, "unixstream{master}", 1);
int backlog = (int) luaL_optnumber(L, 2, 32);
int err = socket_listen(&un->sock, backlog);
if (err != IO_DONE) {
@ -299,7 +299,7 @@ static int meth_listen(lua_State *L)
return 2;
}
/* turn master object into a server object */
auxiliar_setclass(L, "unixtcp{server}", 1);
auxiliar_setclass(L, "unixstream{server}", 1);
lua_pushnumber(L, 1);
return 1;
}
@ -311,9 +311,9 @@ static int meth_shutdown(lua_State *L)
{
/* SHUT_RD, SHUT_WR, SHUT_RDWR have the value 0, 1, 2, so we can use method index directly */
static const char* methods[] = { "receive", "send", "both", NULL };
p_unix tcp = (p_unix) auxiliar_checkclass(L, "unixtcp{client}", 1);
p_unix stream = (p_unix) auxiliar_checkclass(L, "unixstream{client}", 1);
int how = luaL_checkoption(L, 2, "both", methods);
socket_shutdown(&tcp->sock, how);
socket_shutdown(&stream->sock, how);
lua_pushnumber(L, 1);
return 1;
}
@ -322,7 +322,7 @@ static int meth_shutdown(lua_State *L)
* Just call tm methods
\*-------------------------------------------------------------------------*/
static int meth_settimeout(lua_State *L) {
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixtcp{any}", 1);
p_unix un = (p_unix) auxiliar_checkgroup(L, "unixstream{any}", 1);
return timeout_meth_settimeout(L, &un->tm);
}
@ -330,17 +330,17 @@ static int meth_settimeout(lua_State *L) {
* Library functions
\*=========================================================================*/
/*-------------------------------------------------------------------------*\
* Creates a master unixtcp object
* Creates a master unixstream object
\*-------------------------------------------------------------------------*/
static int global_create(lua_State *L) {
t_socket sock;
int err = socket_create(&sock, AF_UNIX, SOCK_STREAM, 0);
/* try to allocate a system socket */
if (err == IO_DONE) {
/* allocate unixtcp object */
/* allocate unixstream object */
p_unix un = (p_unix) lua_newuserdata(L, sizeof(t_unix));
/* set its type as master object */
auxiliar_setclass(L, "unixtcp{master}", -1);
auxiliar_setclass(L, "unixstream{master}", -1);
/* initialize remaining structure fields */
socket_setnonblocking(&sock);
un->sock = sock;

21
src/unixstream.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef UNIXSTREAM_H
#define UNIXSTREAM_H
/*=========================================================================*\
* UNIX STREAM object
* LuaSocket toolkit
*
* The unixstream.h module is basicly a glue that puts together modules buffer.h,
* timeout.h socket.h and inet.h to provide the LuaSocket UNIX STREAM (AF_UNIX,
* SOCK_STREAM) support.
*
* Three classes are defined: master, client and server. The master class is
* a newly created unixstream object, that has not been bound or connected. Server
* objects are unixstream objects bound to some local address. Client objects are
* unixstream objects either connected to some address or returned by the accept
* method of a server object.
\*=========================================================================*/
#include "unix.h"
int unixstream_open(lua_State *L);
#endif /* UNIXSTREAM_H */

21
src/unixtcp.h
View File

@ -1,21 +0,0 @@
#ifndef UNIXTCP_H
#define UNIXTCP_H
/*=========================================================================*\
* UNIX TCP object
* LuaSocket toolkit
*
* The unixtcp.h module is basicly a glue that puts together modules buffer.h,
* timeout.h socket.h and inet.h to provide the LuaSocket UNIX TCP (AF_UNIX,
* SOCK_STREAM) support.
*
* Three classes are defined: master, client and server. The master class is
* a newly created unixtcp object, that has not been bound or connected. Server
* objects are unixtcp objects bound to some local address. Client objects are
* unixtcp objects either connected to some address or returned by the accept
* method of a server object.
\*=========================================================================*/
#include "unix.h"
int unixtcp_open(lua_State *L);
#endif /* UNIXTCP_H */

4
test/unixudpclnt.lua → test/unixdgramclnt.lua
View File

@ -1,7 +1,7 @@
socket = require"socket"
socket.unix = require"socket.unix"
c = assert(socket.unix.udp())
c:bind("/tmp/bar")
c = assert(socket.unix.dgram())
print(c:bind("/tmp/bar"))
while 1 do
local l = io.read("*l")
assert(c:sendto(l, "/tmp/foo"))

2
test/unixudpsrvr.lua → test/unixdgramsrvr.lua
View File

@ -1,6 +1,6 @@
socket = require"socket"
socket.unix = require"socket.unix"
u = assert(socket.unix.udp())
u = assert(socket.unix.dgram())
assert(u:bind("/tmp/foo"))
while 1 do
x, r = assert(u:receivefrom())

2
test/unixtcpclnt.lua → test/unixstreamclnt.lua
View File

@ -1,6 +1,6 @@
socket = require"socket"
socket.unix = require"socket.unix"
c = assert(socket.unix.tcp())
c = assert(socket.unix.stream())
assert(c:connect("/tmp/foo"))
while 1 do
local l = io.read()

2
test/unixtcpsrvr.lua → test/unixstreamsrvr.lua
View File

@ -1,6 +1,6 @@
socket = require"socket"
socket.unix = require"socket.unix"
u = assert(socket.unix.tcp())
u = assert(socket.unix.stream())
assert(u:bind("/tmp/foo"))
assert(u:listen())
c = assert(u:accept())