1 

     2 #include <lua.h>

     3 #include <lauxlib.h>

     4 #include <glib.h>

     5 #include <loudmouth/loudmouth.h>

     6 

     7 #include "lm_types.h"

     8 #include "util.h"

     9 

    10 /// lm.message_handler

    11 /// Module, representing message handling functions.

    12 

    13 /// message handler callback function

    14 /// Callback function, used on incoming messages.

    15 /// Should return true if message has been fully handled and no more

    16 /// handlers should be called.

    17 /// A: lm connection object, lm message object

    18 /// R: boolean

    19 LmHandlerResult llm_message_handler_callback (LmMessageHandler *handler, LmConnection *connection, LmMessage *message, llm_callback_t *cb)

    20 {

    21 	int ret;

    22 	lua_rawgeti (cb->L, LUA_REGISTRYINDEX, cb->reference);

    23 	llm_connection_bless (cb->L, connection);

    24 	// XXX lm_connection_unref (connection);

    25 	llm_message_bless (cb->L, message);

    26 	// XXX lm_message_unref (message);

    27 	if (lua_pcall (cb->L, 2, 1, 0)) {

    28 		// XXX lua_error (cb->L);

    29 		lua_pop (cb->L, 1);

    30 		return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

    31 	}

    32 	ret = lua_toboolean (cb->L, -1);

    33 	lua_pop (cb->L, 1);

    34 	if (ret)

    35 		return LM_HANDLER_RESULT_REMOVE_MESSAGE;

    36 	else

    37 		return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

    38 }

    39 

    40 /// lm.message_handler.new

    41 /// Creates new message handler object.

    42 /// A: message handler callback function

    43 /// R: lm message handler object

    44 static int llm_message_handler_new (lua_State *L)

    45 {

    46 	llm_callback_t *cb;

    47 	LmMessageHandler *handler;

    48 	luaL_argcheck (L, lua_isfunction (L, 1), 1, "function expected");

    49 

    50 	cb = luaL_malloc (L, sizeof (llm_callback_t));

    51 	cb->reference = luaL_ref (L, LUA_REGISTRYINDEX);

    52 	cb->L         = L;

    53 

    54 	handler = lm_message_handler_new ((LmHandleMessageFunction)llm_message_handler_callback,

    55 					cb, (GDestroyNotify)llm_callback_destroy);

    56 	llm_message_handler_bless (L, handler);

    57 	lm_message_handler_unref (handler); // XXX

    58 	return 1;

    59 }

    60 

    61 /// lm.message_handler.bless

    62 /// Blesses given pointer to lm message handler object.

    63 /// A: lightuserdata (C lm message handler object)

    64 /// R: lm message handler object

    65 static int llm_message_handler_bless_lua (lua_State *L)

    66 {

    67 	luaL_argcheck (L, lua_islightuserdata (L, 1), 1, "loudmouth message handler pointer expected");

    68 	llm_message_handler_bless (L, lua_touserdata (L, 1));

    69 	lua_remove (L, -2);

    70 	return 1;

    71 }

    72 

    73 /// message_handler:invalidate

    74 /// Invalidates handler.

    75 static int llm_message_handler_invalidate (lua_State *L)

    76 {

    77 	llm_message_handler_t *object = luaL_checklm_message_handler (L, 1);

    78 	lm_message_handler_invalidate (object->message_handler);

    79 	lua_pop (L, 1);

    80 	return 0;

    81 }

    82 

    83 /// message_handler:valid

    84 /// Returns true if message handler is still valid.

    85 /// R: boolean

    86 static int llm_message_handler_valid (lua_State *L)

    87 {

    88 	llm_message_handler_t *object = luaL_checklm_message_handler (L, 1);

    89 	lua_pushboolean (L, lm_message_handler_is_valid (object->message_handler));

    90 	lua_remove (L, -2);

    91 	return 1;

    92 }

    93 

    94 /// message_handler:pointer

    95 /// Returns pointer to underlying C loudmouth structure.

    96 /// R: lightuserdata

    97 static int llm_message_handler_pointer (lua_State *L)

    98 {

    99 	llm_message_handler_t *object = luaL_checklm_message_handler (L, 1);

   100 	lua_pushlightuserdata (L, object->message_handler);

   101 	lua_remove (L, -2);

   102 	return 1;

   103 }

   104 

   105 static int llm_message_handler_gc (lua_State *L)

   106 {

   107 	llm_message_handler_t *object = luaL_checklm_message_handler (L, 1);

   108 	lm_message_handler_unref (object->message_handler);

   109 	lua_pop (L, 1);

   110 	return 0;

   111 }

   112 

   113 static const luaL_Reg llm_message_handler_reg_f[] = {

   114 	{ "new",   llm_message_handler_new       },

   115 	{ "bless", llm_message_handler_bless_lua },

   116 	{ NULL,    NULL                          },

   117 };

   118 

   119 static const luaL_Reg llm_message_handler_reg_m[] = {

   120 	{ "invalidate", llm_message_handler_invalidate },

   121 	{ "valid",      llm_message_handler_valid      },

   122 	{ "pointer",    llm_message_handler_pointer    },

   123 	{ "__gc",       llm_message_handler_gc         },

   124 	{ NULL,         NULL                           },

   125 };

   126 

   127 int luaopen_lm_message_handler (lua_State *L)

   128 {

   129 	luaL_newmetatable (L, "loudmouth.message_handler");

   130 	lua_pushstring (L, "__index");

   131 	lua_pushvalue (L, -2);

   132 	lua_settable (L, -3);

   133 	luaL_register (L, NULL, llm_message_handler_reg_m);

   134 	lua_pop (L, 1);

   135 	luaL_register (L, "lm.message_handler", llm_message_handler_reg_f);

   136 	return 1;

   137 }

   138