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
   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 static 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 static 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 static 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         returns number of bytes added
  70 */
  71 static int event_buffer_add(lua_State* L) {
  72         le_buffer* buf = event_buffer_check(L, 1);
  73         struct evbuffer* buffer = buf->buffer;
  74         int oldLength = EVBUFFER_LENGTH(buffer);
  75         int last = lua_gettop(L);
  76         int i;
  77         for(i = 2; i <= last; i++) {
  78                 if(!lua_isstring(L, i) && !is_event_buffer(L, i))
  79                         luaL_argerror(L, i, "Argument is not a string or buffer object");
  80 /* Optionally perform checks and data loading separately to avoid overfilling the buffer */
  81 #if BUFFER_ADD_CHECK_INPUT_FIRST
  82         }
  83         for(i = 2; i <= last; i++) {
  84 #endif
  85                 if(lua_isstring(L, i)) {
  86                         size_t len;
  87                         const char* data = lua_tolstring(L, i, &len);
  88                         if(0 != evbuffer_add(buffer, data, len))
  89                                 luaL_error(L, "Failed to add data to the buffer");
  90                 } else {
  91                         le_buffer* buf2 = event_buffer_check(L, i);
  92                         if(0 != evbuffer_add_buffer(buffer, buf2->buffer))
  93                                 luaL_error(L, "Failed to move buffer-data to the buffer");
  94                 }
  95         }
  96         lua_pushinteger(L, EVBUFFER_LENGTH(buffer) - oldLength);
  97         return 1;
  98 }
  99
 100 /* LUA: buffer:length()
 101         Returns the length of the buffer contents
 102 */
 103 static int event_buffer_get_length(lua_State* L) {
 104         le_buffer* buf = event_buffer_check(L, 1);
 105         lua_pushinteger(L, EVBUFFER_LENGTH(buf->buffer));
 106         return 1;
 107 }
 108
 109 /* MAYBE: Could add caching */
 110 /* LUA: buffer:get_data
 111         () - Returns all data in buffer
 112         (len) - Returns data up to 'len' bytes long
 113         (begin,len) - Returns data beginning at 'begin' up to 'len' bytes long
 114 */
 115 static int event_buffer_get_data(lua_State* L) {
 116         le_buffer* buf = event_buffer_check(L, 1);
 117         int begin, len;
 118         switch(lua_gettop(L)) {
 119         case 1:
 120                 /* Obtain full data */
 121                 begin = 0;
 122                 len = EVBUFFER_LENGTH(buf->buffer);
 123                 break;
 124         case 2:
 125                 begin = 0;
 126                 len = luaL_checkinteger(L, 2);
 127                 if(len > EVBUFFER_LENGTH(buf->buffer))
 128                         len = EVBUFFER_LENGTH(buf->buffer);
 129                 break;
 130         case 3:
 131         default:
 132                 begin = luaL_checkinteger(L, 2);
 133                 len = luaL_checkinteger(L, 3);
 134                 if(begin > EVBUFFER_LENGTH(buf->buffer))
 135                         begin = EVBUFFER_LENGTH(buf->buffer);
 136                 if(begin + len > EVBUFFER_LENGTH(buf->buffer))
 137                         len = EVBUFFER_LENGTH(buf->buffer) - begin;
 138                 break;
 139         }
 140         lua_pushlstring(L, (const char*)EVBUFFER_DATA(buf->buffer) + begin, len);
 141         return 1;
 142 }
 143
 144 /* LUA: buffer:drain(amt)
 145         Drains 'amt' bytes from the buffer
 146 */
 147 static int event_buffer_drain(lua_State* L) {
 148         le_buffer* buf = event_buffer_check(L, 1);
 149         size_t len = luaL_checkinteger(L, 2);
 150         evbuffer_drain(buf->buffer, len);
 151         return 0;
 152 }
 153
 154 static luaL_Reg buffer_funcs[] = {
 155         {"add",event_buffer_add},
 156         {"length",event_buffer_get_length},
 157         {"get_data",event_buffer_get_data},
 158         {"drain",event_buffer_drain},
 159         {"close",event_buffer_gc},
 160         {NULL, NULL}
 161 };
 162 static luaL_Reg funcs[] = {
 163         {"new",event_buffer_push_new},
 164         {NULL, NULL}
 165 };
 166
 167 int event_buffer_register(lua_State* L) {
 168         luaL_newmetatable(L, EVENT_BUFFER_MT);
 169         lua_pushcfunction(L, event_buffer_gc);
 170         lua_setfield(L, -2, "__gc");
 171         lua_newtable(L);
 172         luaL_register(L, NULL, buffer_funcs);
 173         lua_setfield(L, -2, "__index");
 174         lua_pop(L, 1);
 175
 176         luaL_register(L, "luaevent.core.buffer", funcs);
 177         return 0;
 178 }