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 <lauxlib.h>
   6 #include <malloc.h>
   7
   8 #define EVENT_BUFFER_MT "EVENT_BUFFER_MT"
   9
  10 #define BUFFER_ADD_CHECK_INPUT_FIRST 1
  11
  12 /* Obtains an le_buffer structure from a given index */
  13 static le_buffer* event_buffer_get(lua_State* L, int idx) {
  14         return (le_buffer*)luaL_checkudata(L, idx, EVENT_BUFFER_MT);
  15 }
  16
  17 /* Obtains an le_buffer structure from a given index
  18         AND checks that it hadn't been prematurely freed
  19 */
  20 static le_buffer* event_buffer_check(lua_State* L, int idx) {
  21         le_buffer* buf = (le_buffer*)luaL_checkudata(L, idx, EVENT_BUFFER_MT);
  22         if(!buf->buffer)
  23                 luaL_argerror(L, idx, "Attempt to use closed event_buffer object");
  24         return buf;
  25 }
  26
  27 /* Checks if the given index contains an le_buffer object */
  28 static int is_event_buffer(lua_State* L, int idx) {
  29         int ret;
  30         lua_getmetatable(L, idx);
  31         luaL_getmetatable(L, EVENT_BUFFER_MT);
  32         ret = lua_rawequal(L, -2, -1);
  33         lua_pop(L, 2);
  34         return ret;
  35 }
  36
  37 /* TODO: Use lightuserdata mapping to locate hanging object instances */
  38 /* Pushes the specified evbuffer object onto the stack, attaching a metatable to it */
  39 static int event_buffer_push(lua_State* L, struct evbuffer* buffer) {
  40         le_buffer *buf = (le_buffer*)lua_newuserdata(L, sizeof(le_buffer));
  41         buf->buffer = buffer;
  42         luaL_getmetatable(L, EVENT_BUFFER_MT);
  43         lua_setmetatable(L, -2);
  44         return 1;
  45 }
  46
  47 /* LUA: new()
  48         Pushes a new evbuffer instance on the stack
  49 */
  50 static int event_buffer_push_new(lua_State* L) {
  51         return event_buffer_push(L, evbuffer_new());
  52 }
  53
  54 /* LUA: __gc and buffer:close()
  55         Releases the buffer resources
  56 */
  57 static int event_buffer_gc(lua_State* L) {
  58         le_buffer* buf = event_buffer_get(L, 1);
  59         if(buf->buffer) {
  60                 evbuffer_free(buf->buffer);
  61                 buf->buffer = NULL;
  62         }
  63         return 0;
  64 }
  65
  66 /* LUA: buffer:add(...)
  67         progressively adds items to the buffer
  68                 if arg[*] is string, treat as a string:format call
  69                 if arg[*] is a buffer, perform event_add_buffer
  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         for(i = 2; i <= last; i++) {
  79                 if(!lua_isstring(L, i) && !is_event_buffer(L, i))
  80                         luaL_argerror(L, i, "Argument is not a string or buffer object");
  81 /* Optionally perform checks and data loading separately to avoid overfilling the buffer */
  82 #if BUFFER_ADD_CHECK_INPUT_FIRST
  83         }
  84         for(i = 2; i <= last; i++) {
  85 #endif
  86                 if(lua_isstring(L, i)) {
  87                         size_t len;
  88                         const char* data = lua_tolstring(L, i, &len);
  89                         if(0 != evbuffer_add(buffer, data, len))
  90                                 luaL_error(L, "Failed to add data to the buffer");
  91                 } else {
  92                         le_buffer* buf2 = event_buffer_check(L, i);
  93                         if(0 != evbuffer_add_buffer(buffer, buf2->buffer))
  94                                 luaL_error(L, "Failed to move buffer-data to the buffer");
  95                 }
  96         }
  97         lua_pushinteger(L, EVBUFFER_LENGTH(buffer) - oldLength);
  98         return 1;
  99 }
 100
 101 /* LUA: buffer:length()
 102         Returns the length of the buffer contents
 103 */
 104 static int event_buffer_get_length(lua_State* L) {
 105         le_buffer* buf = event_buffer_check(L, 1);
 106         lua_pushinteger(L, EVBUFFER_LENGTH(buf->buffer));
 107         return 1;
 108 }
 109
 110 /* MAYBE: Could add caching */
 111 /* LUA: buffer:get_data
 112         () - Returns all data in buffer
 113         (len) - Returns data up to 'len' bytes long
 114         (begin,len) - Returns data beginning at 'begin' up to 'len' bytes long
 115 */
 116 static int event_buffer_get_data(lua_State* L) {
 117         le_buffer* buf = event_buffer_check(L, 1);
 118         int begin, len;
 119         switch(lua_gettop(L)) {
 120         case 1:
 121                 /* Obtain full data */
 122                 begin = 0;
 123                 len = EVBUFFER_LENGTH(buf->buffer);
 124                 break;
 125         case 2:
 126                 begin = 0;
 127                 len = luaL_checkinteger(L, 2);
 128                 if(len > EVBUFFER_LENGTH(buf->buffer))
 129                         len = EVBUFFER_LENGTH(buf->buffer);
 130                 break;
 131         case 3:
 132         default:
 133                 begin = luaL_checkinteger(L, 2);
 134                 len = luaL_checkinteger(L, 3);
 135                 if(begin > EVBUFFER_LENGTH(buf->buffer))
 136                         begin = EVBUFFER_LENGTH(buf->buffer);
 137                 if(begin + len > EVBUFFER_LENGTH(buf->buffer))
 138                         len = EVBUFFER_LENGTH(buf->buffer) - begin;
 139                 break;
 140         }
 141         lua_pushlstring(L, (const char*)EVBUFFER_DATA(buf->buffer) + begin, len);
 142         return 1;
 143 }
 144
 145 /* LUA: buffer:readline()
 146         Returns a line terminated by either '\r\n','\n\r' or '\r' or '\n'
 147         Returns nil and leaves data alone if no terminator is found
 148         TODO: Evaluate whether or not the newline is included
 149 */
 150 static int event_buffer_readline(lua_State* L) {
 151         le_buffer* buf = event_buffer_check(L, 1);
 152         char* line = evbuffer_readline(buf->buffer);
 153         if(!line)
 154                 return 0;
 155         lua_pushstring(L, line);
 156         free(line);
 157         return 1;
 158 }
 159
 160 /* LUA: buffer:drain(amt)
 161         Drains 'amt' bytes from the buffer
 162 */
 163 static int event_buffer_drain(lua_State* L) {
 164         le_buffer* buf = event_buffer_check(L, 1);
 165         size_t len = luaL_checkinteger(L, 2);
 166         evbuffer_drain(buf->buffer, len);
 167         return 0;
 168 }
 169
 170 static luaL_Reg buffer_funcs[] = {
 171         {"add", event_buffer_add},
 172         {"length", event_buffer_get_length},
 173         {"get_data", event_buffer_get_data},
 174         {"readline", event_buffer_readline},
 175         {"drain", event_buffer_drain},
 176         {"close", event_buffer_gc},
 177         {NULL, NULL}
 178 };
 179 static luaL_Reg funcs[] = {
 180         {"new", event_buffer_push_new},
 181         {NULL, NULL}
 182 };
 183
 184 int event_buffer_register(lua_State* L) {
 185         luaL_newmetatable(L, EVENT_BUFFER_MT);
 186         lua_pushcfunction(L, event_buffer_gc);
 187         lua_setfield(L, -2, "__gc");
 188         lua_newtable(L);
 189         luaL_register(L, NULL, buffer_funcs);
 190         lua_setfield(L, -2, "__index");
 191         lua_pop(L, 1);
 192
 193         luaL_register(L, "luaevent.core.buffer", funcs);
 194         return 0;
 195 }