luaevent-prosody: src/event

/* LuaEvent - Copyright (C) 2007 Thomas Harning <harningt@gmail.com>
 * Licensed as LGPL - See doc/COPYING for details */
#include <stdlib.h>
#include "event_buffer.h"
#include <lauxlib.h>
 
#define EVENT_BUFFER_MT "EVENT_BUFFER_MT"
 
#define BUFFER_ADD_CHECK_INPUT_FIRST 1
 
/* Obtains an le_buffer structure from a given index */
static le_buffer* event_buffer_get(lua_State* L, int idx) {
	return (le_buffer*)luaL_checkudata(L, idx, EVENT_BUFFER_MT);
}
 
/* Obtains an le_buffer structure from a given index
	AND checks that it hadn't been prematurely freed
*/
le_buffer* event_buffer_check(lua_State* L, int idx) {
	le_buffer* buf = (le_buffer*)luaL_checkudata(L, idx, EVENT_BUFFER_MT);
	if(!buf->buffer)
		luaL_argerror(L, idx, "Attempt to use closed event_buffer object");
	return buf;
}
 
/* Checks if the given index contains an le_buffer object */
int is_event_buffer(lua_State* L, int idx) {
	int ret;
	lua_getmetatable(L, idx);
	luaL_getmetatable(L, EVENT_BUFFER_MT);
	ret = lua_rawequal(L, -2, -1);
	lua_pop(L, 2);
	return ret;
}
 
/* TODO: Use lightuserdata mapping to locate hanging object instances */
/* Pushes the specified evbuffer object onto the stack, attaching a metatable to it */
int event_buffer_push(lua_State* L, struct evbuffer* buffer) {
	le_buffer *buf = (le_buffer*)lua_newuserdata(L, sizeof(le_buffer));
	buf->buffer = buffer;
	luaL_getmetatable(L, EVENT_BUFFER_MT);
	lua_setmetatable(L, -2);
	return 1;
}
 
/* LUA: new()
	Pushes a new evbuffer instance on the stack
*/
static int event_buffer_push_new(lua_State* L) {
	return event_buffer_push(L, evbuffer_new());
}
 
/* LUA: __gc and buffer:close()
	Releases the buffer resources
*/
static int event_buffer_gc(lua_State* L) {
	le_buffer* buf = event_buffer_get(L, 1);
	if(buf->buffer) {
		evbuffer_free(buf->buffer);
		buf->buffer = NULL;
	}
	return 0;
}
 
/* LUA: buffer:add(...)
	progressively adds items to the buffer
		if arg[*] is string, treat as a string:format call
		if arg[*] is a buffer, perform event_add_buffer
	expects at least 1 other argument
	returns number of bytes added
*/
static int event_buffer_add(lua_State* L) {
	le_buffer* buf = event_buffer_check(L, 1);
	struct evbuffer* buffer = buf->buffer;
	int oldLength = EVBUFFER_LENGTH(buffer);
	int last = lua_gettop(L);
	int i;
	if(last == 1) luaL_error(L, "Not enough arguments to add: expects at least 1 additional operand");
	for(i = 2; i <= last; i++) {
		if(!lua_isstring(L, i) && !is_event_buffer(L, i))
			luaL_argerror(L, i, "Argument is not a string or buffer object");
		if(lua_equal(L, 1, i))
			luaL_argerror(L, i, "Cannot add buffer to itself");
/* Optionally perform checks and data loading separately to avoid overfilling the buffer */
#if BUFFER_ADD_CHECK_INPUT_FIRST
	}
	for(i = 2; i <= last; i++) {
#endif
		if(lua_isstring(L, i)) {
			size_t len;
			const char* data = lua_tolstring(L, i, &len);
			if(0 != evbuffer_add(buffer, data, len))
				luaL_error(L, "Failed to add data to the buffer");
		} else {
			le_buffer* buf2 = event_buffer_check(L, i);
			if(0 != evbuffer_add_buffer(buffer, buf2->buffer))
				luaL_error(L, "Failed to move buffer-data to the buffer");
		}
	}
	lua_pushinteger(L, EVBUFFER_LENGTH(buffer) - oldLength);
	return 1;
}
 
/* LUA: buffer:length()
	Returns the length of the buffer contents
*/
static int event_buffer_get_length(lua_State* L) {
	le_buffer* buf = event_buffer_check(L, 1);
	lua_pushinteger(L, EVBUFFER_LENGTH(buf->buffer));
	return 1;
}
 
/* MAYBE: Could add caching */
/* LUA: buffer:get_data
	() - Returns all data in buffer
	(len) - Returns data up to 'len' bytes long
	(begin,len) - Returns data beginning at 'begin' up to 'len' bytes long
	If begin < 0, wraps at data length
		ex: (-1, 1) returns last character
		(-2,2) returns last 2 chars [length meaning does not get inverted]
*/
static int event_buffer_get_data(lua_State* L) {
	le_buffer* buf = event_buffer_check(L, 1);
	int begin, len;
	switch(lua_gettop(L)) {
	case 1:
		/* Obtain full data */
		begin = 0;
		len = EVBUFFER_LENGTH(buf->buffer);
		break;
	case 2:
		begin = 0;
		len = luaL_checkinteger(L, 2);
		if(len > EVBUFFER_LENGTH(buf->buffer))
			len = EVBUFFER_LENGTH(buf->buffer);
		break;
	case 3:
	default:
		/* - 1 to map it to Lua's 1-based indexing
		 * If begin < 0 add length to cause position wrapping
		 */
		begin = luaL_checkinteger(L, 2);
		if(begin < 0)
			begin += EVBUFFER_LENGTH(buf->buffer);
		else
			begin--;
		len = luaL_checkinteger(L, 3);
		/* If length is less than zero, capture entire remaining string */
 
		if(len < 0) len = EVBUFFER_LENGTH(buf->buffer);
		if(begin > EVBUFFER_LENGTH(buf->buffer))
			begin = EVBUFFER_LENGTH(buf->buffer);
		if(begin + len > EVBUFFER_LENGTH(buf->buffer))
			len = EVBUFFER_LENGTH(buf->buffer) - begin;
		break;
	}
	lua_pushlstring(L, (const char*)EVBUFFER_DATA(buf->buffer) + begin, len);
	return 1;
}
 
/* LUA: buffer:readline()
	Returns a line terminated by either '\r\n','\n\r' or '\r' or '\n'
	Returns nil and leaves data alone if no terminator is found
	Newline is not present in the captured string.
*/
static int event_buffer_readline(lua_State* L) {
	le_buffer* buf = event_buffer_check(L, 1);
	char* line = evbuffer_readline(buf->buffer);
	if(!line)
		return 0;
	lua_pushstring(L, line);
	free(line);
	return 1;
}
 
/* LUA: buffer:drain(amt)
	Drains 'amt' bytes from the buffer
	If amt < 0, drains all data
		(Due to auto-casting to unsigned int and automatic capping)
*/
static int event_buffer_drain(lua_State* L) {
	le_buffer* buf = event_buffer_check(L, 1);
	size_t len = luaL_checkinteger(L, 2);
	evbuffer_drain(buf->buffer, len);
	return 0;
}
 
/* LUA: buffer:write
	(integer/lightuserdata fd) - Attempts to write all the data out to the FD
	(socket) - Attempts to write all the data out to the socket object
*/
static int event_buffer_write(lua_State* L) {
	le_buffer* buf = event_buffer_check(L, 1);
	int ret;
	if(lua_isnumber(L, 2)) {
		ret = evbuffer_write(buf->buffer, lua_tointeger(L, 2));
	} else if(lua_islightuserdata(L, 2)) {
		ret = evbuffer_write(buf->buffer, (int)(long)lua_touserdata(L, 2));
	} else if(lua_isuserdata(L, 2)) {
		ret = evbuffer_write(buf->buffer, getSocketFd(L, 2));
	} else {
		ret = 0; /* Shush uninitialized warning */
		luaL_argerror(L, 2, "Unexpected data type.  Expects: integer/lightuserdata/socket");
	}
	lua_pushinteger(L, ret);
	return 1;
}
 
/* LUA: buffer:read
	(integer/lightuserdata fd, len) - Attempts to read up to 'len' out of the FD
	(socket, len) - Attempts to read up to 'len' out of the socket object
*/
static int event_buffer_read(lua_State* L) {
	le_buffer* buf = event_buffer_check(L, 1);
	int len = luaL_checkinteger(L, 3);
	int ret;
	if(lua_isnumber(L, 2)) {
		ret = evbuffer_read(buf->buffer, lua_tointeger(L, 2), len);
	} else if(lua_islightuserdata(L, 2)) {
		ret = evbuffer_read(buf->buffer, (int)(long)lua_touserdata(L, 2), len);
	} else if(lua_isuserdata(L, 2)) {
		ret = evbuffer_read(buf->buffer, getSocketFd(L, 2), len);
	} else {
		ret = 0; /* Shush uninitialized warning */
		luaL_argerror(L, 2, "Unexpected data type.  Expects: integer/lightuserdata/socket");
	}
	lua_pushinteger(L, ret);
	return 1;
}
static luaL_Reg buffer_funcs[] = {
	{"add", event_buffer_add},
	{"length", event_buffer_get_length},
	{"get_data", event_buffer_get_data},
	{"readline", event_buffer_readline},
	{"drain", event_buffer_drain},
	{"close", event_buffer_gc},
	{"read", event_buffer_read},
	{"write", event_buffer_write},
	{NULL, NULL}
};
static luaL_Reg funcs[] = {
	{"new", event_buffer_push_new},
	{NULL, NULL}
};
 
int event_buffer_register(lua_State* L) {
	luaL_newmetatable(L, EVENT_BUFFER_MT);
	lua_pushcfunction(L, event_buffer_gc);
	lua_setfield(L, -2, "__gc");
	lua_pushcfunction(L, event_buffer_get_length);
	lua_setfield(L, -2, "__len");
	lua_pushcfunction(L, event_buffer_get_data);
	lua_setfield(L, -2, "__tostring");
	lua_newtable(L);
	luaL_register(L, NULL, buffer_funcs);
	lua_setfield(L, -2, "__index");
	lua_pop(L, 1);
	
	luaL_register(L, "luaevent.core.buffer", 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 "event_buffer.h"
5	#include <lauxlib.h>
6
7	#define EVENT_BUFFER_MT "EVENT_BUFFER_MT"
8
9	#define BUFFER_ADD_CHECK_INPUT_FIRST 1
10
11	/* Obtains an le_buffer structure from a given index */
12	static le_buffer* event_buffer_get(lua_State* L, int idx) {
13	return (le_buffer*)luaL_checkudata(L, idx, EVENT_BUFFER_MT);
14	}
15
16	/* Obtains an le_buffer structure from a given index
17	AND checks that it hadn't been prematurely freed
18	*/
19	le_buffer* event_buffer_check(lua_State* L, int idx) {
20	le_buffer* buf = (le_buffer*)luaL_checkudata(L, idx, EVENT_BUFFER_MT);
21	if(!buf->buffer)
22	luaL_argerror(L, idx, "Attempt to use closed event_buffer object");
23	return buf;
24	}
25
26	/* Checks if the given index contains an le_buffer object */
27	int is_event_buffer(lua_State* L, int idx) {
28	int ret;
29	lua_getmetatable(L, idx);
30	luaL_getmetatable(L, EVENT_BUFFER_MT);
31	ret = lua_rawequal(L, -2, -1);
32	lua_pop(L, 2);
33	return ret;
34	}
35
36	/* TODO: Use lightuserdata mapping to locate hanging object instances */
37	/* Pushes the specified evbuffer object onto the stack, attaching a metatable to it */
38	int event_buffer_push(lua_State* L, struct evbuffer* buffer) {
39	le_buffer buf = (le_buffer)lua_newuserdata(L, sizeof(le_buffer));
40	buf->buffer = buffer;
41	luaL_getmetatable(L, EVENT_BUFFER_MT);
42	lua_setmetatable(L, -2);
43	return 1;
44	}
45
46	/* LUA: new()
47	Pushes a new evbuffer instance on the stack
48	*/
49	static int event_buffer_push_new(lua_State* L) {
50	return event_buffer_push(L, evbuffer_new());
51	}
52
53	/* LUA: __gc and buffer:close()
54	Releases the buffer resources
55	*/
56	static int event_buffer_gc(lua_State* L) {
57	le_buffer* buf = event_buffer_get(L, 1);
58	if(buf->buffer) {
59	evbuffer_free(buf->buffer);
60	buf->buffer = NULL;
61	}
62	return 0;
63	}
64
65	/* LUA: buffer:add(...)
66	progressively adds items to the buffer
67	if arg[*] is string, treat as a string:format call
68	if arg[*] is a buffer, perform event_add_buffer
69	expects at least 1 other argument
70	returns number of bytes added
71	*/
72	static int event_buffer_add(lua_State* L) {
73	le_buffer* buf = event_buffer_check(L, 1);
74	struct evbuffer* buffer = buf->buffer;
75	int oldLength = EVBUFFER_LENGTH(buffer);
76	int last = lua_gettop(L);
77	int i;
78	if(last == 1) luaL_error(L, "Not enough arguments to add: expects at least 1 additional operand");
79	for(i = 2; i <= last; i++) {
80	if(!lua_isstring(L, i) && !is_event_buffer(L, i))
81	luaL_argerror(L, i, "Argument is not a string or buffer object");
82	if(lua_equal(L, 1, i))
83	luaL_argerror(L, i, "Cannot add buffer to itself");
84	/* Optionally perform checks and data loading separately to avoid overfilling the buffer */
85	#if BUFFER_ADD_CHECK_INPUT_FIRST
86	}
87	for(i = 2; i <= last; i++) {
88	#endif
89	if(lua_isstring(L, i)) {
90	size_t len;
91	const char* data = lua_tolstring(L, i, &len);
92	if(0 != evbuffer_add(buffer, data, len))
93	luaL_error(L, "Failed to add data to the buffer");
94	} else {
95	le_buffer* buf2 = event_buffer_check(L, i);
96	if(0 != evbuffer_add_buffer(buffer, buf2->buffer))
97	luaL_error(L, "Failed to move buffer-data to the buffer");
98	}
99	}
100	lua_pushinteger(L, EVBUFFER_LENGTH(buffer) - oldLength);
101	return 1;
102	}
103
104	/* LUA: buffer:length()
105	Returns the length of the buffer contents
106	*/
107	static int event_buffer_get_length(lua_State* L) {
108	le_buffer* buf = event_buffer_check(L, 1);
109	lua_pushinteger(L, EVBUFFER_LENGTH(buf->buffer));
110	return 1;
111	}
112
113	/* MAYBE: Could add caching */
114	/* LUA: buffer:get_data
115	() - Returns all data in buffer
116	(len) - Returns data up to 'len' bytes long
117	(begin,len) - Returns data beginning at 'begin' up to 'len' bytes long
118	If begin < 0, wraps at data length
119	ex: (-1, 1) returns last character
120	(-2,2) returns last 2 chars [length meaning does not get inverted]
121	*/
122	static int event_buffer_get_data(lua_State* L) {
123	le_buffer* buf = event_buffer_check(L, 1);
124	int begin, len;
125	switch(lua_gettop(L)) {
126	case 1:
127	/* Obtain full data */
128	begin = 0;
129	len = EVBUFFER_LENGTH(buf->buffer);
130	break;
131	case 2:
132	begin = 0;
133	len = luaL_checkinteger(L, 2);
134	if(len > EVBUFFER_LENGTH(buf->buffer))
135	len = EVBUFFER_LENGTH(buf->buffer);
136	break;
137	case 3:
138	default:
139	/* - 1 to map it to Lua's 1-based indexing
140	* If begin < 0 add length to cause position wrapping
141	*/
142	begin = luaL_checkinteger(L, 2);
143	if(begin < 0)
144	begin += EVBUFFER_LENGTH(buf->buffer);
145	else
146	begin--;
147	len = luaL_checkinteger(L, 3);
148	/* If length is less than zero, capture entire remaining string */
149
150	if(len < 0) len = EVBUFFER_LENGTH(buf->buffer);
151	if(begin > EVBUFFER_LENGTH(buf->buffer))
152	begin = EVBUFFER_LENGTH(buf->buffer);
153	if(begin + len > EVBUFFER_LENGTH(buf->buffer))
154	len = EVBUFFER_LENGTH(buf->buffer) - begin;
155	break;
156	}
157	lua_pushlstring(L, (const char*)EVBUFFER_DATA(buf->buffer) + begin, len);
158	return 1;
159	}
160
161	/* LUA: buffer:readline()
162	Returns a line terminated by either '\r\n','\n\r' or '\r' or '\n'
163	Returns nil and leaves data alone if no terminator is found
164	Newline is not present in the captured string.
165	*/
166	static int event_buffer_readline(lua_State* L) {
167	le_buffer* buf = event_buffer_check(L, 1);
168	char* line = evbuffer_readline(buf->buffer);
169	if(!line)
170	return 0;
171	lua_pushstring(L, line);
172	free(line);
173	return 1;
174	}
175
176	/* LUA: buffer:drain(amt)
177	Drains 'amt' bytes from the buffer
178	If amt < 0, drains all data
179	(Due to auto-casting to unsigned int and automatic capping)
180	*/
181	static int event_buffer_drain(lua_State* L) {
182	le_buffer* buf = event_buffer_check(L, 1);
183	size_t len = luaL_checkinteger(L, 2);
184	evbuffer_drain(buf->buffer, len);
185	return 0;
186	}
187
188	/* LUA: buffer:write
189	(integer/lightuserdata fd) - Attempts to write all the data out to the FD
190	(socket) - Attempts to write all the data out to the socket object
191	*/
192	static int event_buffer_write(lua_State* L) {
193	le_buffer* buf = event_buffer_check(L, 1);
194	int ret;
195	if(lua_isnumber(L, 2)) {
196	ret = evbuffer_write(buf->buffer, lua_tointeger(L, 2));
197	} else if(lua_islightuserdata(L, 2)) {
198	ret = evbuffer_write(buf->buffer, (int)(long)lua_touserdata(L, 2));
199	} else if(lua_isuserdata(L, 2)) {
200	ret = evbuffer_write(buf->buffer, getSocketFd(L, 2));
201	} else {
202	ret = 0; /* Shush uninitialized warning */
203	luaL_argerror(L, 2, "Unexpected data type. Expects: integer/lightuserdata/socket");
204	}
205	lua_pushinteger(L, ret);
206	return 1;
207	}
208
209	/* LUA: buffer:read
210	(integer/lightuserdata fd, len) - Attempts to read up to 'len' out of the FD
211	(socket, len) - Attempts to read up to 'len' out of the socket object
212	*/
213	static int event_buffer_read(lua_State* L) {
214	le_buffer* buf = event_buffer_check(L, 1);
215	int len = luaL_checkinteger(L, 3);
216	int ret;
217	if(lua_isnumber(L, 2)) {
218	ret = evbuffer_read(buf->buffer, lua_tointeger(L, 2), len);
219	} else if(lua_islightuserdata(L, 2)) {
220	ret = evbuffer_read(buf->buffer, (int)(long)lua_touserdata(L, 2), len);
221	} else if(lua_isuserdata(L, 2)) {
222	ret = evbuffer_read(buf->buffer, getSocketFd(L, 2), len);
223	} else {
224	ret = 0; /* Shush uninitialized warning */
225	luaL_argerror(L, 2, "Unexpected data type. Expects: integer/lightuserdata/socket");
226	}
227	lua_pushinteger(L, ret);
228	return 1;
229	}
230	static luaL_Reg buffer_funcs[] = {
231	{"add", event_buffer_add},
232	{"length", event_buffer_get_length},
233	{"get_data", event_buffer_get_data},
234	{"readline", event_buffer_readline},
235	{"drain", event_buffer_drain},
236	{"close", event_buffer_gc},
237	{"read", event_buffer_read},
238	{"write", event_buffer_write},
239	{NULL, NULL}
240	};
241	static luaL_Reg funcs[] = {
242	{"new", event_buffer_push_new},
243	{NULL, NULL}
244	};
245
246	int event_buffer_register(lua_State* L) {
247	luaL_newmetatable(L, EVENT_BUFFER_MT);
248	lua_pushcfunction(L, event_buffer_gc);
249	lua_setfield(L, -2, "__gc");
250	lua_pushcfunction(L, event_buffer_get_length);
251	lua_setfield(L, -2, "__len");
252	lua_pushcfunction(L, event_buffer_get_data);
253	lua_setfield(L, -2, "__tostring");
254	lua_newtable(L);
255	luaL_register(L, NULL, buffer_funcs);
256	lua_setfield(L, -2, "__index");
257	lua_pop(L, 1);
258
259	luaL_register(L, "luaevent.core.buffer", funcs);
260	return 1;
261	}

src/event_buffer.c