src/buffer_event.c

   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         ev->ev->wm_read.low = low;
 157         ev->ev->wm_read.high = high;
 158         return 0;
 159 }
 160
 161 static int buffer_event_set_write_watermarks(lua_State* L) {
 162         int low, high;
 163         le_bufferevent* ev = buffer_event_get(L, 1);
 164         if(!ev->ev) return 0;
 165
 166         low = lua_tonumber(L, 2);
 167         high = lua_tonumber(L, 3);
 168
 169         ev->ev->wm_write.low = low;
 170         ev->ev->wm_write.high = high;
 171         return 0;
 172 }
 173
 174 static int buffer_event_get_read_watermarks(lua_State* L) {
 175         le_bufferevent* ev = buffer_event_get(L, 1);
 176         if(!ev->ev) return 0;
 177
 178         lua_pushinteger(L, ev->ev->wm_read.low);
 179         lua_pushinteger(L, ev->ev->wm_read.high);
 180         return 2;
 181 }
 182
 183 static int buffer_event_get_write_watermarks(lua_State* L) {
 184         le_bufferevent* ev = buffer_event_get(L, 1);
 185         if(!ev->ev) return 0;
 186
 187         lua_pushinteger(L, ev->ev->wm_write.low);
 188         lua_pushinteger(L, ev->ev->wm_write.high);
 189         return 2;
 190 }
 191
 192 static int buffer_event_set_timeouts(lua_State* L) {
 193         int timeout_read, timeout_write;
 194         le_bufferevent* ev = buffer_event_get(L, 1);
 195         if(!ev->ev) return 0;
 196
 197         timeout_read = lua_tointeger(L, 2);
 198         timeout_write = lua_tointeger(L, 3);
 199
 200         bufferevent_settimeout(ev->ev, timeout_read, timeout_write);
 201         return 0;
 202 }
 203
 204 static int buffer_event_get_timeouts(lua_State* L) {
 205         le_bufferevent* ev = buffer_event_get(L, 1);
 206         if(!ev->ev) return 0;
 207
 208         lua_pushinteger(L, ev->ev->timeout_read);
 209         lua_pushinteger(L, ev->ev->timeout_write);
 210         return 2;
 211 }
 212
 213 static int buffer_event_enable(lua_State* L) {
 214         le_bufferevent* ev = buffer_event_get(L, 1);
 215         if(!ev->ev) return 0;
 216
 217         lua_pushinteger(L, bufferevent_enable(ev->ev, luaL_checkinteger(L, 2)));
 218         return 1;
 219 }
 220
 221 static int buffer_event_disable(lua_State* L) {
 222         le_bufferevent* ev = buffer_event_get(L, 1);
 223         if(!ev->ev) return 0;
 224
 225         lua_pushinteger(L, bufferevent_disable(ev->ev, luaL_checkinteger(L, 2)));
 226         return 1;
 227 }
 228
 229 static luaL_Reg buffer_event_funcs[] = {
 230         {"get_read", buffer_event_get_read},
 231         {"get_write", buffer_event_get_write},
 232         {"set_read_watermarks", buffer_event_set_read_watermarks},
 233         {"set_write_watermarks", buffer_event_set_write_watermarks},
 234         {"get_read_watermarks", buffer_event_get_read_watermarks},
 235         {"get_write_watermarks", buffer_event_get_write_watermarks},
 236         {"set_timeouts", buffer_event_set_timeouts},
 237         {"get_timeouts", buffer_event_get_timeouts},
 238         {"enable", buffer_event_enable},
 239         {"disable", buffer_event_disable},
 240         {NULL, NULL}
 241 };
 242
 243 static luaL_Reg funcs[] = {
 244         {"new", buffer_event_push},
 245         {NULL, NULL}
 246 };
 247
 248 int buffer_event_register(lua_State* L) {
 249         luaL_newmetatable(L, BUFFER_EVENT_MT);
 250         lua_pushcfunction(L, buffer_event_gc);
 251         lua_setfield(L, -2, "__gc");
 252         lua_newtable(L);
 253         luaL_register(L, NULL, buffer_event_funcs);
 254         lua_setfield(L, -2, "__index");
 255         lua_pop(L, 1);
 256
 257         luaL_register(L, "luaevent.core.bufferevent", funcs);
 258         return 1;
 259 }