luaevent-prosody: src/buffer

/* LuaEvent - Copyright (C) 2007 Thomas Harning <harningt@gmail.com>
 * Licensed as LGPL - See doc/COPYING for details */
#include <stdlib.h>
#include "buffer_event.h"
#include "utility.h"
#include <lauxlib.h>
#include "event_buffer.h"
 
#define BUFFER_EVENT_MT "BUFFER_EVENT_MT"
 
/* Locations of READ/WRITE buffers in the fenv */
#define READ_BUFFER_LOCATION 4
#define WRITE_BUFFER_LOCATION 5
 
/* Obtains an le_bufferevent structure from a given index */
static le_bufferevent* buffer_event_get(lua_State* L, int idx) {
	return (le_bufferevent*)luaL_checkudata(L, idx, BUFFER_EVENT_MT);
}
 
/* Obtains an le_bufferevent structure from a given index
	AND checks that it hadn't been prematurely freed
*/
le_bufferevent* buffer_event_check(lua_State* L, int idx) {
	le_bufferevent* buf = (le_bufferevent*)luaL_checkudata(L, idx, BUFFER_EVENT_MT);
	if(!buf->ev)
		luaL_argerror(L, idx, "Attempt to use closed buffer_event object");
	return buf;
}
 
/* Checks if the given index contains an le_buffer object */
int is_buffer_event(lua_State* L, int idx) {
	int ret;
	lua_getmetatable(L, idx);
	luaL_getmetatable(L, BUFFER_EVENT_MT);
	ret = lua_rawequal(L, -2, -1);
	lua_pop(L, 2);
	return ret;
}
 
static void handle_callback(le_bufferevent* le_ev, short what, int callbackIndex) {
	lua_State* L = le_ev->base->loop_L;
	le_weak_get(L, le_ev);
	lua_getfenv(L, -1);
	lua_rawgeti(L, -1, callbackIndex);
	lua_remove(L, -2);
	lua_pushvalue(L, -2);
	lua_remove(L, -3);
	/* func, bufferevent */
	lua_pushinteger(L, what);
	/* What to do w/ errors...? */
	if(!lua_pcall(L, 2, 0, 0))
	{
		/* FIXME: Perhaps luaevent users should be
		 * able to set an error handler? */
		lua_pop(L, 1); /* Pop error message */
	}
}
 
static void buffer_event_readcb(struct bufferevent *ev, void *ptr) {
	handle_callback((le_bufferevent*)ptr, EVBUFFER_READ, 1);
}
 
static void buffer_event_writecb(struct bufferevent *ev, void *ptr) {
	handle_callback((le_bufferevent*)ptr, EVBUFFER_WRITE, 2);
}
 
static void buffer_event_errorcb(struct bufferevent *ev, short what, void *ptr) {
	handle_callback((le_bufferevent*)ptr, what, 3);
}
 
/* LUA: new(fd, read, write, error)
	Pushes a new bufferevent instance on the stack
	Accepts: base, fd, read, write, error cb
	Requires base, fd and error cb
*/
static int buffer_event_push(lua_State* L) {
	le_bufferevent *ev;
	le_base* base = event_base_get(L, 1);
	/* NOTE: Should probably reference the socket as well... */
	int fd = getSocketFd(L, 2);
	luaL_checktype(L, 5, LUA_TFUNCTION);
	if(!lua_isnil(L, 3)) luaL_checktype(L, 3, LUA_TFUNCTION);
	if(!lua_isnil(L, 4)) luaL_checktype(L, 4, LUA_TFUNCTION);
	ev= (le_bufferevent*)lua_newuserdata(L, sizeof(le_bufferevent));
	luaL_getmetatable(L, BUFFER_EVENT_MT);
	lua_setmetatable(L, -2);
	ev->ev = bufferevent_new(fd, buffer_event_readcb, buffer_event_writecb, buffer_event_errorcb, ev);
	lua_createtable(L, 5, 0);
	lua_pushvalue(L, 3);
	lua_rawseti(L, -2, 1); // Read
	lua_pushvalue(L, 4);
	lua_rawseti(L, -2, 2); // Write
	lua_pushvalue(L, 5);
	lua_rawseti(L, -2, 3); // Err
 
	event_buffer_push(L, ev->ev->input);
	lua_rawseti(L, -2, READ_BUFFER_LOCATION);
	event_buffer_push(L, ev->ev->output);
	lua_rawseti(L, -2, WRITE_BUFFER_LOCATION);
	lua_setfenv(L, -2);
	ev->base = base;
	return 1;
}
 
/* LUA: __gc and buffer:close()
	Releases the buffer resources
*/
static int buffer_event_gc(lua_State* L) {
	le_bufferevent* ev = buffer_event_get(L, 1);
	if(ev->ev) {
		le_buffer *read, *write;
		bufferevent_free(ev->ev);
		ev->ev = NULL;
		/* Also clear out the associated input/output event_buffers
		 * since they would have already been freed.. */
		lua_getfenv(L, 1);
		lua_rawgeti(L, -1, READ_BUFFER_LOCATION);
		lua_rawgeti(L, -2, WRITE_BUFFER_LOCATION);
		read = event_buffer_check(L, -2);
		write = event_buffer_check(L, -1);
		/* Erase Lua's link to the buffers */
		lua_pushnil(L);
		/* LS: ..., fenv, readBuf, writeBuf, nil */
		lua_rawseti(L, -4, READ_BUFFER_LOCATION);
		lua_pushnil(L);
		lua_rawseti(L, -4, WRITE_BUFFER_LOCATION);
		/* Erase their knowledge of the buffer so that the GC won't try to double-free */
		read->buffer = NULL;
		write->buffer = NULL;
	}
	return 0;
}
 
static int buffer_event_get_read(lua_State* L) {
	(void)buffer_event_get(L, 1);
	lua_getfenv(L, 1);
	lua_rawgeti(L, -1, READ_BUFFER_LOCATION);
	return 1;
}
 
static int buffer_event_get_write(lua_State* L) {
	(void)buffer_event_get(L, 1);
	lua_getfenv(L, 1);
	lua_rawgeti(L, -1, WRITE_BUFFER_LOCATION);
	return 1;
}
 
static int buffer_event_set_read_watermarks(lua_State* L) {
	int low, high;
	le_bufferevent* ev = buffer_event_get(L, 1);
	if(!ev->ev) return 0;
 
	low = lua_tonumber(L, 2);
	high = lua_tonumber(L, 3);
 
	bufferevent_setwatermark(ev->ev, EV_READ, low, high);
	return 0;
}
 
static int buffer_event_set_write_watermarks(lua_State* L) {
	int low, high;
	le_bufferevent* ev = buffer_event_get(L, 1);
	if(!ev->ev) return 0;
 
	low = lua_tonumber(L, 2);
	high = lua_tonumber(L, 3);
 
	bufferevent_setwatermark(ev->ev, EV_WRITE, low, high);
	return 0;
}
 
static int buffer_event_set_timeouts(lua_State* L) {
	int timeout_read, timeout_write;
	le_bufferevent* ev = buffer_event_get(L, 1);
	if(!ev->ev) return 0;
 
	timeout_read = lua_tointeger(L, 2);
	timeout_write = lua_tointeger(L, 3);
 
	bufferevent_settimeout(ev->ev, timeout_read, timeout_write);
	return 0;
}
 
static int buffer_event_enable(lua_State* L) {
	le_bufferevent* ev = buffer_event_get(L, 1);
	if(!ev->ev) return 0;
 
	lua_pushinteger(L, bufferevent_enable(ev->ev, luaL_checkinteger(L, 2)));
	return 1;
}
 
static int buffer_event_disable(lua_State* L) {
	le_bufferevent* ev = buffer_event_get(L, 1);
	if(!ev->ev) return 0;
 
	lua_pushinteger(L, bufferevent_disable(ev->ev, luaL_checkinteger(L, 2)));
	return 1;
}
 
static luaL_Reg buffer_event_funcs[] = {
	{"get_read", buffer_event_get_read},
	{"get_write", buffer_event_get_write},
	{"set_read_watermarks", buffer_event_set_read_watermarks},
	{"set_write_watermarks", buffer_event_set_write_watermarks},
	{"set_timeouts", buffer_event_set_timeouts},
	{"enable", buffer_event_enable},
	{"disable", buffer_event_disable},
	{NULL, NULL}
};
 
static luaL_Reg funcs[] = {
	{"new", buffer_event_push},
	{NULL, NULL}
};
 
int buffer_event_register(lua_State* L) {
	luaL_newmetatable(L, BUFFER_EVENT_MT);
	lua_pushcfunction(L, buffer_event_gc);
	lua_setfield(L, -2, "__gc");
	lua_newtable(L);
	luaL_register(L, NULL, buffer_event_funcs);
	lua_setfield(L, -2, "__index");
	lua_pop(L, 1);
 
	luaL_register(L, "luaevent.core.bufferevent", funcs);
	return 1;
}

1	/* LuaEvent - Copyright (C) 2007 Thomas Harning <harningt@gmail.com>
2	* Licensed as LGPL - See doc/COPYING for details */
3	#include <stdlib.h>
4	#include "buffer_event.h"
5	#include "utility.h"
6	#include <lauxlib.h>
7	#include "event_buffer.h"
8
9	#define BUFFER_EVENT_MT "BUFFER_EVENT_MT"
10
11	/* Locations of READ/WRITE buffers in the fenv */
12	#define READ_BUFFER_LOCATION 4
13	#define WRITE_BUFFER_LOCATION 5
14
15	/* Obtains an le_bufferevent structure from a given index */
16	static le_bufferevent* buffer_event_get(lua_State* L, int idx) {
17	return (le_bufferevent*)luaL_checkudata(L, idx, BUFFER_EVENT_MT);
18	}
19
20	/* Obtains an le_bufferevent structure from a given index
21	AND checks that it hadn't been prematurely freed
22	*/
23	le_bufferevent* buffer_event_check(lua_State* L, int idx) {
24	le_bufferevent* buf = (le_bufferevent*)luaL_checkudata(L, idx, BUFFER_EVENT_MT);
25	if(!buf->ev)
26	luaL_argerror(L, idx, "Attempt to use closed buffer_event object");
27	return buf;
28	}
29
30	/* Checks if the given index contains an le_buffer object */
31	int is_buffer_event(lua_State* L, int idx) {
32	int ret;
33	lua_getmetatable(L, idx);
34	luaL_getmetatable(L, BUFFER_EVENT_MT);
35	ret = lua_rawequal(L, -2, -1);
36	lua_pop(L, 2);
37	return ret;
38	}
39
40	static void handle_callback(le_bufferevent* le_ev, short what, int callbackIndex) {
41	lua_State* L = le_ev->base->loop_L;
42	le_weak_get(L, le_ev);
43	lua_getfenv(L, -1);
44	lua_rawgeti(L, -1, callbackIndex);
45	lua_remove(L, -2);
46	lua_pushvalue(L, -2);
47	lua_remove(L, -3);
48	/* func, bufferevent */
49	lua_pushinteger(L, what);
50	/* What to do w/ errors...? */
51	if(!lua_pcall(L, 2, 0, 0))
52	{
53	/* FIXME: Perhaps luaevent users should be
54	* able to set an error handler? */
55	lua_pop(L, 1); /* Pop error message */
56	}
57	}
58
59	static void buffer_event_readcb(struct bufferevent ev, void ptr) {
60	handle_callback((le_bufferevent*)ptr, EVBUFFER_READ, 1);
61	}
62
63	static void buffer_event_writecb(struct bufferevent ev, void ptr) {
64	handle_callback((le_bufferevent*)ptr, EVBUFFER_WRITE, 2);
65	}
66
67	static void buffer_event_errorcb(struct bufferevent ev, short what, void ptr) {
68	handle_callback((le_bufferevent*)ptr, what, 3);
69	}
70
71	/* LUA: new(fd, read, write, error)
72	Pushes a new bufferevent instance on the stack
73	Accepts: base, fd, read, write, error cb
74	Requires base, fd and error cb
75	*/
76	static int buffer_event_push(lua_State* L) {
77	le_bufferevent *ev;
78	le_base* base = event_base_get(L, 1);
79	/* NOTE: Should probably reference the socket as well... */
80	int fd = getSocketFd(L, 2);
81	luaL_checktype(L, 5, LUA_TFUNCTION);
82	if(!lua_isnil(L, 3)) luaL_checktype(L, 3, LUA_TFUNCTION);
83	if(!lua_isnil(L, 4)) luaL_checktype(L, 4, LUA_TFUNCTION);
84	ev= (le_bufferevent*)lua_newuserdata(L, sizeof(le_bufferevent));
85	luaL_getmetatable(L, BUFFER_EVENT_MT);
86	lua_setmetatable(L, -2);
87	ev->ev = bufferevent_new(fd, buffer_event_readcb, buffer_event_writecb, buffer_event_errorcb, ev);
88	lua_createtable(L, 5, 0);
89	lua_pushvalue(L, 3);
90	lua_rawseti(L, -2, 1); // Read
91	lua_pushvalue(L, 4);
92	lua_rawseti(L, -2, 2); // Write
93	lua_pushvalue(L, 5);
94	lua_rawseti(L, -2, 3); // Err
95
96	event_buffer_push(L, ev->ev->input);
97	lua_rawseti(L, -2, READ_BUFFER_LOCATION);
98	event_buffer_push(L, ev->ev->output);
99	lua_rawseti(L, -2, WRITE_BUFFER_LOCATION);
100	lua_setfenv(L, -2);
101	ev->base = base;
102	return 1;
103	}
104
105	/* LUA: __gc and buffer:close()
106	Releases the buffer resources
107	*/
108	static int buffer_event_gc(lua_State* L) {
109	le_bufferevent* ev = buffer_event_get(L, 1);
110	if(ev->ev) {
111	le_buffer read, write;
112	bufferevent_free(ev->ev);
113	ev->ev = NULL;
114	/* Also clear out the associated input/output event_buffers
115	* since they would have already been freed.. */
116	lua_getfenv(L, 1);
117	lua_rawgeti(L, -1, READ_BUFFER_LOCATION);
118	lua_rawgeti(L, -2, WRITE_BUFFER_LOCATION);
119	read = event_buffer_check(L, -2);
120	write = event_buffer_check(L, -1);
121	/* Erase Lua's link to the buffers */
122	lua_pushnil(L);
123	/* LS: ..., fenv, readBuf, writeBuf, nil */
124	lua_rawseti(L, -4, READ_BUFFER_LOCATION);
125	lua_pushnil(L);
126	lua_rawseti(L, -4, WRITE_BUFFER_LOCATION);
127	/* Erase their knowledge of the buffer so that the GC won't try to double-free */
128	read->buffer = NULL;
129	write->buffer = NULL;
130	}
131	return 0;
132	}
133
134	static int buffer_event_get_read(lua_State* L) {
135	(void)buffer_event_get(L, 1);
136	lua_getfenv(L, 1);
137	lua_rawgeti(L, -1, READ_BUFFER_LOCATION);
138	return 1;
139	}
140
141	static int buffer_event_get_write(lua_State* L) {
142	(void)buffer_event_get(L, 1);
143	lua_getfenv(L, 1);
144	lua_rawgeti(L, -1, WRITE_BUFFER_LOCATION);
145	return 1;
146	}
147
148	static int buffer_event_set_read_watermarks(lua_State* L) {
149	int low, high;
150	le_bufferevent* ev = buffer_event_get(L, 1);
151	if(!ev->ev) return 0;
152
153	low = lua_tonumber(L, 2);
154	high = lua_tonumber(L, 3);
155
156	bufferevent_setwatermark(ev->ev, EV_READ, low, high);
157	return 0;
158	}
159
160	static int buffer_event_set_write_watermarks(lua_State* L) {
161	int low, high;
162	le_bufferevent* ev = buffer_event_get(L, 1);
163	if(!ev->ev) return 0;
164
165	low = lua_tonumber(L, 2);
166	high = lua_tonumber(L, 3);
167
168	bufferevent_setwatermark(ev->ev, EV_WRITE, low, high);
169	return 0;
170	}
171
172	static int buffer_event_set_timeouts(lua_State* L) {
173	int timeout_read, timeout_write;
174	le_bufferevent* ev = buffer_event_get(L, 1);
175	if(!ev->ev) return 0;
176
177	timeout_read = lua_tointeger(L, 2);
178	timeout_write = lua_tointeger(L, 3);
179
180	bufferevent_settimeout(ev->ev, timeout_read, timeout_write);
181	return 0;
182	}
183
184	static int buffer_event_enable(lua_State* L) {
185	le_bufferevent* ev = buffer_event_get(L, 1);
186	if(!ev->ev) return 0;
187
188	lua_pushinteger(L, bufferevent_enable(ev->ev, luaL_checkinteger(L, 2)));
189	return 1;
190	}
191
192	static int buffer_event_disable(lua_State* L) {
193	le_bufferevent* ev = buffer_event_get(L, 1);
194	if(!ev->ev) return 0;
195
196	lua_pushinteger(L, bufferevent_disable(ev->ev, luaL_checkinteger(L, 2)));
197	return 1;
198	}
199
200	static luaL_Reg buffer_event_funcs[] = {
201	{"get_read", buffer_event_get_read},
202	{"get_write", buffer_event_get_write},
203	{"set_read_watermarks", buffer_event_set_read_watermarks},
204	{"set_write_watermarks", buffer_event_set_write_watermarks},
205	{"set_timeouts", buffer_event_set_timeouts},
206	{"enable", buffer_event_enable},
207	{"disable", buffer_event_disable},
208	{NULL, NULL}
209	};
210
211	static luaL_Reg funcs[] = {
212	{"new", buffer_event_push},
213	{NULL, NULL}
214	};
215
216	int buffer_event_register(lua_State* L) {
217	luaL_newmetatable(L, BUFFER_EVENT_MT);
218	lua_pushcfunction(L, buffer_event_gc);
219	lua_setfield(L, -2, "__gc");
220	lua_newtable(L);
221	luaL_register(L, NULL, buffer_event_funcs);
222	lua_setfield(L, -2, "__index");
223	lua_pop(L, 1);
224
225	luaL_register(L, "luaevent.core.bufferevent", funcs);
226	return 1;
227	}

src/buffer_event.c