src/event_buffer.c

   1 /* LuaEvent - Copyright (C) 2007 Thomas Harning <harningt@gmail.com>
   2  * Licensed as LGPL - See doc/COPYING for details */
   3
   4 #include "event_buffer.h"
   5 #include "luaevent.h"
   6 #include <lauxlib.h>
   7 #include <malloc.h>
   8
   9 #define EVENT_BUFFER_MT "EVENT_BUFFER_MT"
  10
  11 #define BUFFER_ADD_CHECK_INPUT_FIRST 1
  12
  13 /* Obtains an le_buffer structure from a given index */
  14 static le_buffer* event_buffer_get(lua_State* L, int idx) {
  15         return (le_buffer*)luaL_checkudata(L, idx, EVENT_BUFFER_MT);
  16 }
  17
  18 /* Obtains an le_buffer structure from a given index
  19         AND checks that it hadn't been prematurely freed
  20 */
  21 static le_buffer* event_buffer_check(lua_State* L, int idx) {
  22         le_buffer* buf = (le_buffer*)luaL_checkudata(L, idx, EVENT_BUFFER_MT);
  23         if(!buf->buffer)
  24                 luaL_argerror(L, idx, "Attempt to use closed event_buffer object");
  25         return buf;
  26 }
  27
  28 /* Checks if the given index contains an le_buffer object */
  29 static int is_event_buffer(lua_State* L, int idx) {
  30         int ret;
  31         lua_getmetatable(L, idx);
  32         luaL_getmetatable(L, EVENT_BUFFER_MT);
  33         ret = lua_rawequal(L, -2, -1);
  34         lua_pop(L, 2);
  35         return ret;
  36 }
  37
  38 /* TODO: Use lightuserdata mapping to locate hanging object instances */
  39 /* Pushes the specified evbuffer object onto the stack, attaching a metatable to it */
  40 static int event_buffer_push(lua_State* L, struct evbuffer* buffer) {
  41         le_buffer *buf = (le_buffer*)lua_newuserdata(L, sizeof(le_buffer));
  42         buf->buffer = buffer;
  43         luaL_getmetatable(L, EVENT_BUFFER_MT);
  44         lua_setmetatable(L, -2);
  45         return 1;
  46 }
  47
  48 /* LUA: new()
  49         Pushes a new evbuffer instance on the stack
  50 */
  51 static int event_buffer_push_new(lua_State* L) {
  52         return event_buffer_push(L, evbuffer_new());
  53 }
  54
  55 /* LUA: __gc and buffer:close()
  56         Releases the buffer resources
  57 */
  58 static int event_buffer_gc(lua_State* L) {
  59         le_buffer* buf = event_buffer_get(L, 1);
  60         if(buf->buffer) {
  61                 evbuffer_free(buf->buffer);
  62                 buf->buffer = NULL;
  63         }
  64         return 0;
  65 }
  66
  67 /* LUA: buffer:add(...)
  68         progressively adds items to the buffer
  69                 if arg[*] is string, treat as a string:format call
  70                 if arg[*] is a buffer, perform event_add_buffer
  71         returns number of bytes added
  72 */
  73 static int event_buffer_add(lua_State* L) {
  74         le_buffer* buf = event_buffer_check(L, 1);
  75         struct evbuffer* buffer = buf->buffer;
  76         int oldLength = EVBUFFER_LENGTH(buffer);
  77         int last = lua_gettop(L);
  78         int i;
  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 */
 119 static int event_buffer_get_data(lua_State* L) {
 120         le_buffer* buf = event_buffer_check(L, 1);
 121         int begin, len;
 122         switch(lua_gettop(L)) {
 123         case 1:
 124                 /* Obtain full data */
 125                 begin = 0;
 126                 len = EVBUFFER_LENGTH(buf->buffer);
 127                 break;
 128         case 2:
 129                 begin = 0;
 130                 len = luaL_checkinteger(L, 2);
 131                 if(len > EVBUFFER_LENGTH(buf->buffer))
 132                         len = EVBUFFER_LENGTH(buf->buffer);
 133                 break;
 134         case 3:
 135         default:
 136                 begin = luaL_checkinteger(L, 2);
 137                 len = luaL_checkinteger(L, 3);
 138                 if(begin > EVBUFFER_LENGTH(buf->buffer))
 139                         begin = EVBUFFER_LENGTH(buf->buffer);
 140                 if(begin + len > EVBUFFER_LENGTH(buf->buffer))
 141                         len = EVBUFFER_LENGTH(buf->buffer) - begin;
 142                 break;
 143         }
 144         lua_pushlstring(L, (const char*)EVBUFFER_DATA(buf->buffer) + begin, len);
 145         return 1;
 146 }
 147
 148 /* LUA: buffer:readline()
 149         Returns a line terminated by either '\r\n','\n\r' or '\r' or '\n'
 150         Returns nil and leaves data alone if no terminator is found
 151         TODO: Evaluate whether or not the newline is included
 152 */
 153 static int event_buffer_readline(lua_State* L) {
 154         le_buffer* buf = event_buffer_check(L, 1);
 155         char* line = evbuffer_readline(buf->buffer);
 156         if(!line)
 157                 return 0;
 158         lua_pushstring(L, line);
 159         free(line);
 160         return 1;
 161 }
 162
 163 /* LUA: buffer:drain(amt)
 164         Drains 'amt' bytes from the buffer
 165 */
 166 static int event_buffer_drain(lua_State* L) {
 167         le_buffer* buf = event_buffer_check(L, 1);
 168         size_t len = luaL_checkinteger(L, 2);
 169         evbuffer_drain(buf->buffer, len);
 170         return 0;
 171 }
 172
 173 /* LUA: buffer:write
 174         (integer/lightuserdata fd) - Attempts to write all the data out to the FD
 175         (socket) - Attempts to write all the data out to the socket object
 176 */
 177 static int event_buffer_write(lua_State* L) {
 178         le_buffer* buf = event_buffer_check(L, 1);
 179         int ret;
 180         if(lua_isnumber(L, 2)) {
 181                 ret = evbuffer_write(buf->buffer, lua_tointeger(L, 2));
 182         } else if(lua_islightuserdata(L, 2)) {
 183                 ret = evbuffer_write(buf->buffer, (int)(long)lua_touserdata(L, 2));
 184         } else if(lua_isuserdata(L, 2)) {
 185                 ret = evbuffer_write(buf->buffer, getSocketFd(L, 2));
 186         } else {
 187                 luaL_argerror(L, 2, "Unexpected data type.  Expects: integer/lightuserdata/socket");
 188         }
 189         lua_pushinteger(L, ret);
 190         return 1;
 191 }
 192
 193 /* LUA: buffer:read
 194         (integer/lightuserdata fd, len) - Attempts to read up to 'len' out of the FD
 195         (socket, len) - Attempts to read up to 'len' out of the socket object
 196 */
 197 static int event_buffer_read(lua_State* L) {
 198         le_buffer* buf = event_buffer_check(L, 1);
 199         int len = luaL_checkinteger(L, 3);
 200         int ret;
 201         if(lua_isnumber(L, 2)) {
 202                 ret = evbuffer_read(buf->buffer, lua_tointeger(L, 2), len);
 203         } else if(lua_islightuserdata(L, 2)) {
 204                 ret = evbuffer_read(buf->buffer, (int)(long)lua_touserdata(L, 2), len);
 205         } else if(lua_isuserdata(L, 2)) {
 206                 ret = evbuffer_read(buf->buffer, getSocketFd(L, 2), len);
 207         } else {
 208                 luaL_argerror(L, 2, "Unexpected data type.  Expects: integer/lightuserdata/socket");
 209         }
 210         lua_pushinteger(L, ret);
 211         return 1;
 212 }
 213 static luaL_Reg buffer_funcs[] = {
 214         {"add", event_buffer_add},
 215         {"length", event_buffer_get_length},
 216         {"get_data", event_buffer_get_data},
 217         {"readline", event_buffer_readline},
 218         {"drain", event_buffer_drain},
 219         {"close", event_buffer_gc},
 220         {"read", event_buffer_read},
 221         {"write", event_buffer_write},
 222         {NULL, NULL}
 223 };
 224 static luaL_Reg funcs[] = {
 225         {"new", event_buffer_push_new},
 226         {NULL, NULL}
 227 };
 228
 229 int event_buffer_register(lua_State* L) {
 230         luaL_newmetatable(L, EVENT_BUFFER_MT);
 231         lua_pushcfunction(L, event_buffer_gc);
 232         lua_setfield(L, -2, "__gc");
 233         lua_pushcfunction(L, event_buffer_get_length);
 234         lua_setfield(L, -2, "__len");
 235         lua_pushcfunction(L, event_buffer_get_data);
 236         lua_setfield(L, -2, "__tostring");
 237         lua_newtable(L);
 238         luaL_register(L, NULL, buffer_funcs);
 239         lua_setfield(L, -2, "__index");
 240         lua_pop(L, 1);
 241
 242         luaL_register(L, "luaevent.core.buffer", funcs);
 243         return 0;
 244 }