// Called from lua to stop listening to a particular event
static int addon_output_event_listen_stop(lua_State *L) {
// Args should be :
// 1) self
// 2) event name
// Find the event
const char *evt_name = luaL_checkstring(L, 2);
struct event_reg *evt = event_find(evt_name);
if (!evt)
luaL_error(L, "Event %s does not exists", evt_name);
// Get the output
struct addon_instance_priv *p = addon_output_get_priv(L, 1);
if (event_listener_unregister(evt, p) != POM_OK)
luaL_error(L, "Error while unregistering event listener");
// Forget about listening to the event
lua_pushlightuserdata(L, evt);
lua_pushnil(L);
lua_settable(L, 1);
return 0;
}
event_request_t *event_add( context_t *ctx, const long fd, unsigned int flags )
{
event_request_t *entry = event_find( ctx, fd, flags );
//x_printf(ctx, "EVENT ADD called. fd = %ld, flags = %02x (%c)\n",fd,flags,flags&EH_READ?'r':(flags&EH_WRITE?'w':(flags&EH_SPECIAL?'S':'?')));
if( !entry )
entry = event_find_free_slot();
if( ! entry )
return 0L;
entry->fd = fd;
entry->flags |= flags;
entry->ctx = ctx;
if( flags & EH_SIGNAL ) {
// For signals, make sure the handler is installed
if( ! sigismember( &event_signals.event_signal_mask, (int)fd ) ) {
struct sigaction action_handler;
memset( &action_handler, 0, sizeof( action_handler ) );
action_handler.sa_handler = handle_signal_event;
action_handler.sa_flags = 0; // SA_RESTART;
sigaction( (int)fd, &action_handler, NULL );
sigaddset( &event_signals.event_signal_mask, (int) fd );
sigdelset( &event_signals.event_signal_default, (int) fd );
}
} else if( flags & EH_WANT_TICK ) {
entry->timestamp = rel_time(0L);
} else
// For un-special file descriptors, force non-blocking
if( (flags & (EH_READ|EH_WRITE)) && ! ( flags & EH_SPECIAL ) )
fcntl((int)fd, F_SETFL, fcntl((int)fd, F_GETFL) | O_NONBLOCK);
return entry;
}
event_request_t *event_set( const context_t *ctx, const long fd, const unsigned int flags )
{
event_request_t *entry = event_find( ctx, fd, flags );
// Reset flags, but make sure the special bits dont accidentally change.
if( entry )
entry->flags = (entry->flags & EH_SPECIAL) | ( flags & ~(unsigned int)EH_SPECIAL );
return entry;
}
boolean
still_capture(char *fname)
{
Event *event;
int n;
MMAL_STATUS_T status;
boolean result = FALSE;
/* timelapse_shapshot() also uses the still_jpeg_encoder, so wait if busy.
*/
for (n = 0; n < 5; ++n)
{
if (still_jpeg_encoder.file == NULL)
break;
usleep(50000);
}
if (still_jpeg_encoder.file != NULL)
{
/* inform() */
log_printf("still capture failed because jpeg encoder is busy.\n");
return FALSE;
}
if ((still_jpeg_encoder.file = fopen(fname, "w")) == NULL)
log_printf("Could not create still file %s. %m\n", fname);
else
{
if ((status = mmal_port_parameter_set_boolean(
camera.component->output[CAMERA_CAPTURE_PORT],
MMAL_PARAMETER_CAPTURE, 1)) != MMAL_SUCCESS)
{
fclose(still_jpeg_encoder.file);
still_jpeg_encoder.file = NULL;
log_printf("Still capture startup failed. Status %s\n",
mmal_status[status]);
}
else
{
result = TRUE;
log_printf("Still: %s\n", fname);
dup_string(&pikrellcam.still_last_save, fname);
n = pikrellcam.notify_duration * EVENT_LOOP_FREQUENCY;
if ((event = event_find("still saved")) != NULL)
event->count = n; /* rapid stills, extend the time */
else
event_count_down_add("still saved", n,
event_notify_expire, &pikrellcam.still_notify);
pikrellcam.still_capture_event = TRUE;
pikrellcam.still_notify = TRUE;
}
}
return result;
}
// Called from lua to listen to a new event from an instance
static int addon_output_event_listen_start(lua_State *L) {
// Args should be :
// 1) self
// 2) event name
// 3) process_begin
// 4) process_end
// Find the event
const char *evt_name = luaL_checkstring(L, 2);
struct event_reg *evt = event_find(evt_name);
if (!evt)
luaL_error(L, "Event %s does not exists", evt_name);
// Check which function we should register
int (*process_begin) (struct event *evt, void *obj, struct proto_process_stack *stack, unsigned int stack_index) = NULL;
int (*process_end) (struct event *evt, void *obj) = NULL;
if (lua_isfunction(L, 3))
process_begin = addon_event_process_begin;
if (lua_isfunction(L, 4))
process_end = addon_event_process_end;
// Get the output
struct addon_instance_priv *p = addon_output_get_priv(L, 1);
if (event_listener_register(evt, p, process_begin, process_end) != POM_OK)
luaL_error(L, "Error while listening to event %s", evt_name);
// Add a table to self for the processing functions of this event
lua_newtable(L);
lua_pushlightuserdata(L, evt);
lua_pushvalue(L, -2);
lua_settable(L, 1);
// Add the processing function
if (process_begin) {
lua_pushliteral(L, "begin");
lua_pushvalue(L, 3);
lua_settable(L, -3);
}
if (process_end) {
lua_pushliteral(L, "end");
lua_pushvalue(L, 4);
lua_settable(L, -3);
}
pomlog(POMLOG_DEBUG "Output listening to event %s", evt_name);
return 0;
}
/* delete an event from the table */
void event_delete(EVH *func, void *arg)
{
uint32_t i = event_find(func, arg);
if (i == -1)
return;
slog(LG_DEBUG, "event_delete(): removing \"%s\"", event_table[i].name);
event_table[i].name = NULL;
event_table[i].func = NULL;
event_table[i].arg = NULL;
event_table[i].active = FALSE;
cnt.event--;
}
/* delete an event from the table */
void event_delete(EVH *func, void *arg)
{
int i = event_find(func, arg);
if (i == -1)
return;
slog(LG_DEBUG, "event_delete(): removing \"%s\"", event_table[i].name);
if (last_event_ran == event_table[i].name)
last_event_ran = "<removed>";
event_table[i].name = NULL;
event_table[i].func = NULL;
event_table[i].arg = NULL;
event_table[i].active = false;
claro_state.event--;
}
void event_delete( context_t *ctx, const long fd, event_handler_flags_t flags )
{
event_request_t *entry = event_find( ctx, fd, flags );
//x_printf(ctx,"EVENT DELETE called. fd = %ld, flags = %02x (%c) = %p\n",fd,flags,flags&EH_READ?'r':(flags&EH_WRITE?'w':(flags&EH_SPECIAL?'S':'?')), entry);
if( entry ) {
if( flags )
entry->flags &= ~(unsigned int)flags;
else
entry->flags = EH_UNUSED;
if( entry->flags == EH_UNUSED ) {
//x_printf(ctx,"No events for this file descriptor, disabling\n");
entry->fd = -1;
}
//x_printf(ctx,"EVENT remaining - fd = %ld, flags = %02x (%c)\n",entry->fd,entry->flags,entry->flags&EH_READ?'r':(entry->flags&EH_WRITE?'w':(entry->flags&EH_SPECIAL?'S':'?')));
}
}
int output_log_xml_open(void *output_priv) {
struct output_log_xml_priv *priv = output_priv;
if (addon_log_xml_open(priv) != POM_OK)
return POM_ERR;
if (!strlen(PTYPE_STRING_GETVAL(priv->p_source))) {
pomlog(POMLOG_ERR "You need to specify a source for this output");
goto err;
}
char *src = strdup(PTYPE_STRING_GETVAL(priv->p_source));
if (!src) {
pom_oom(strlen(PTYPE_STRING_GETVAL(priv->p_source)));
goto err;
}
char *token, *saveptr, *str = src;
for (; ; str = NULL) {
token = strtok_r(str, ", ", &saveptr);
if (!token)
break;
struct event_reg *evt = event_find(token);
if (!evt) {
pomlog(POMLOG_WARN "Event \"%s\" does not exists", token);
continue;
}
struct output_log_xml_evt *evt_lst = malloc(sizeof(struct output_log_xml_evt));
if (!evt_lst) {
pom_oom(sizeof(struct output_log_xml_evt));
free(src);
goto err;
}
memset(evt_lst, 0, sizeof(struct output_log_xml_evt));
evt_lst->evt = evt;
// Start listening to the event
if (event_listener_register(evt, priv, NULL, output_log_xml_process, NULL) != POM_OK) {
free(evt_lst);
free(src);
goto err;
}
evt_lst->next = priv->evt_lst;
priv->evt_lst = evt_lst;
}
free(src);
if (!priv->evt_lst)
goto err;
return POM_OK;
err:
output_log_xml_close(priv);
return POM_ERR;
}
static int analyzer_smtp_init(struct analyzer *analyzer) {
struct analyzer_smtp_priv *priv = malloc(sizeof(struct analyzer_smtp_priv));
if (!priv) {
pom_oom(sizeof(struct analyzer_smtp_priv));
return POM_ERR;
}
memset(priv, 0, sizeof(struct analyzer_smtp_priv));
analyzer->priv = priv;
priv->evt_cmd = event_find("smtp_cmd");
priv->evt_reply = event_find("smtp_reply");
if (!priv->evt_cmd || !priv->evt_reply)
goto err;
static struct data_item_reg evt_msg_data_items[ANALYZER_SMTP_EVT_MSG_DATA_COUNT] = { { 0 } };
evt_msg_data_items[analyzer_smtp_common_client_addr].name = "client_addr";
evt_msg_data_items[analyzer_smtp_common_client_addr].flags = DATA_REG_FLAG_NO_ALLOC;
evt_msg_data_items[analyzer_smtp_common_server_addr].name = "server_addr";
evt_msg_data_items[analyzer_smtp_common_server_addr].flags = DATA_REG_FLAG_NO_ALLOC;
evt_msg_data_items[analyzer_smtp_common_server_port].name = "server_port";
evt_msg_data_items[analyzer_smtp_common_server_port].value_type = ptype_get_type("uint16");
evt_msg_data_items[analyzer_smtp_common_server_host].name = "server_host";
evt_msg_data_items[analyzer_smtp_common_server_host].value_type = ptype_get_type("string");
evt_msg_data_items[analyzer_smtp_common_server_hello].name = "server_hello";
evt_msg_data_items[analyzer_smtp_common_server_hello].value_type = ptype_get_type("string");
evt_msg_data_items[analyzer_smtp_common_client_hello].name = "client_hello";
evt_msg_data_items[analyzer_smtp_common_client_hello].value_type = ptype_get_type("string");
evt_msg_data_items[analyzer_smtp_msg_from].name = "from";
evt_msg_data_items[analyzer_smtp_msg_from].value_type = ptype_get_type("string");
evt_msg_data_items[analyzer_smtp_msg_to].name = "to";
evt_msg_data_items[analyzer_smtp_msg_to].flags = DATA_REG_FLAG_LIST;
evt_msg_data_items[analyzer_smtp_msg_result].name = "result";
evt_msg_data_items[analyzer_smtp_msg_result].value_type = ptype_get_type("uint16");
static struct data_reg evt_msg_data = {
.items = evt_msg_data_items,
.data_count = ANALYZER_SMTP_EVT_MSG_DATA_COUNT
};
static struct event_reg_info analyzer_smtp_evt_msg = { 0 };
analyzer_smtp_evt_msg.source_name = "analyzer_smtp";
analyzer_smtp_evt_msg.source_obj = analyzer;
analyzer_smtp_evt_msg.name = "smtp_msg";
analyzer_smtp_evt_msg.description = "message received over smtp";
analyzer_smtp_evt_msg.data_reg = &evt_msg_data;
analyzer_smtp_evt_msg.listeners_notify = analyzer_smtp_event_listeners_notify;
analyzer_smtp_evt_msg.cleanup = analyzer_smtp_evt_msg_cleanup;
analyzer_smtp_evt_msg.flags = EVENT_REG_FLAG_PAYLOAD;
priv->evt_msg = event_register(&analyzer_smtp_evt_msg);
if (!priv->evt_msg)
goto err;
static struct data_item_reg evt_auth_data_items[ANALYZER_SMTP_EVT_AUTH_DATA_COUNT] = { { 0 } };
evt_auth_data_items[analyzer_smtp_common_client_addr].name = "client_addr";
evt_auth_data_items[analyzer_smtp_common_client_addr].flags = DATA_REG_FLAG_NO_ALLOC;
evt_auth_data_items[analyzer_smtp_common_server_addr].name = "server_addr";
evt_auth_data_items[analyzer_smtp_common_server_addr].flags = DATA_REG_FLAG_NO_ALLOC;
evt_auth_data_items[analyzer_smtp_common_server_port].name = "server_port";
evt_auth_data_items[analyzer_smtp_common_server_port].value_type = ptype_get_type("uint16");
evt_auth_data_items[analyzer_smtp_common_server_host].name = "server_host";
evt_auth_data_items[analyzer_smtp_common_server_host].value_type = ptype_get_type("string");
evt_auth_data_items[analyzer_smtp_common_server_hello].name = "server_hello";
evt_auth_data_items[analyzer_smtp_common_server_hello].value_type = ptype_get_type("string");
evt_auth_data_items[analyzer_smtp_common_client_hello].name = "client_hello";
evt_auth_data_items[analyzer_smtp_common_client_hello].value_type = ptype_get_type("string");
evt_auth_data_items[analyzer_smtp_auth_type].name = "type";
evt_auth_data_items[analyzer_smtp_auth_type].value_type = ptype_get_type("string");
evt_auth_data_items[analyzer_smtp_auth_params].name = "params";
evt_auth_data_items[analyzer_smtp_auth_params].flags = DATA_REG_FLAG_LIST;
evt_auth_data_items[analyzer_smtp_auth_success].name = "success";
evt_auth_data_items[analyzer_smtp_auth_success].value_type = ptype_get_type("bool");
static struct data_reg evt_auth_data = {
.items = evt_auth_data_items,
.data_count = ANALYZER_SMTP_EVT_AUTH_DATA_COUNT
};
static struct event_reg_info analyzer_smtp_evt_auth = { 0 };
analyzer_smtp_evt_auth.source_name = "analyzer_smtp";
analyzer_smtp_evt_auth.source_obj = analyzer;
analyzer_smtp_evt_auth.name = "smtp_auth";
analyzer_smtp_evt_auth.description = "SMTP authentication attempts";
analyzer_smtp_evt_auth.data_reg = &evt_auth_data;
analyzer_smtp_evt_auth.listeners_notify = analyzer_smtp_event_listeners_notify;
priv->evt_auth = event_register(&analyzer_smtp_evt_auth);
if (!priv->evt_auth)
goto err;
return POM_OK;
err:
analyzer_smtp_cleanup(analyzer);
return POM_ERR;
}
int analyzer_ppp_pap_init(struct analyzer *analyzer) {
struct analyzer_ppp_pap_priv *priv = malloc(sizeof(struct analyzer_ppp_pap_priv));
if (!priv) {
pom_oom(sizeof(struct analyzer_ppp_pap_priv));
return POM_ERR;
}
memset(priv, 0, sizeof(struct analyzer_ppp_pap_priv));
analyzer->priv = priv;
priv->evt_request = event_find("ppp_pap_request");
priv->evt_ack_nack = event_find("ppp_pap_ack_nack");
if (!priv->evt_request || !priv->evt_ack_nack)
goto err;
static struct data_item_reg evt_auth_data_items[ANALYZER_PPP_PAP_AUTH_DATA_COUNT] = { { 0 } };
evt_auth_data_items[analyzer_ppp_pap_auth_client].name = "client";
evt_auth_data_items[analyzer_ppp_pap_auth_client].flags = DATA_REG_FLAG_NO_ALLOC;
evt_auth_data_items[analyzer_ppp_pap_auth_server].name = "server";
evt_auth_data_items[analyzer_ppp_pap_auth_server].flags = DATA_REG_FLAG_NO_ALLOC;
evt_auth_data_items[analyzer_ppp_pap_auth_top_proto].name = "top_proto";
evt_auth_data_items[analyzer_ppp_pap_auth_top_proto].value_type = ptype_get_type("string");
evt_auth_data_items[analyzer_ppp_pap_auth_vlan].name = "vlan";
evt_auth_data_items[analyzer_ppp_pap_auth_vlan].flags = DATA_REG_FLAG_NO_ALLOC;
evt_auth_data_items[analyzer_ppp_pap_auth_identifier].name = "identifier";
evt_auth_data_items[analyzer_ppp_pap_auth_identifier].value_type = ptype_get_type("uint8");
evt_auth_data_items[analyzer_ppp_pap_auth_success].name = "success";
evt_auth_data_items[analyzer_ppp_pap_auth_success].value_type = ptype_get_type("bool");
evt_auth_data_items[analyzer_ppp_pap_auth_peer_id].name = "peer_id";
evt_auth_data_items[analyzer_ppp_pap_auth_peer_id].value_type = ptype_get_type("string");
evt_auth_data_items[analyzer_ppp_pap_auth_password].name = "password";
evt_auth_data_items[analyzer_ppp_pap_auth_password].value_type = ptype_get_type("string");
static struct data_reg evt_auth_data = {
.items = evt_auth_data_items,
.data_count = ANALYZER_PPP_PAP_AUTH_DATA_COUNT
};
static struct event_reg_info analyzer_ppp_pap_evt_auth = { 0 };
analyzer_ppp_pap_evt_auth.source_name = "analyzer_ppp_pap";
analyzer_ppp_pap_evt_auth.source_obj = analyzer;
analyzer_ppp_pap_evt_auth.name = "ppp_pap_auth";
analyzer_ppp_pap_evt_auth.description = "PPP PAP MD5 authentication";
analyzer_ppp_pap_evt_auth.data_reg = &evt_auth_data;
analyzer_ppp_pap_evt_auth.listeners_notify = analyzer_ppp_pap_event_listeners_notify;
priv->evt_auth = event_register(&analyzer_ppp_pap_evt_auth);
if (!priv->evt_auth)
goto err;
return POM_OK;
err:
analyzer_ppp_pap_cleanup(analyzer);
return POM_ERR;
}
int analyzer_eap_init(struct analyzer *analyzer) {
struct analyzer_eap_priv *priv = malloc(sizeof(struct analyzer_eap_priv));
if (!priv) {
pom_oom(sizeof(struct analyzer_eap_priv));
return POM_ERR;
}
memset(priv, 0, sizeof(struct analyzer_eap_priv));
analyzer->priv = priv;
priv->evt_md5_challenge = event_find("eap_md5_challenge");
priv->evt_success_failure = event_find("eap_success_failure");
if (!priv->evt_md5_challenge || !priv->evt_success_failure)
goto err;
static struct data_item_reg evt_md5_auth_data_items[ANALYZER_EAP_MD5_AUTH_DATA_COUNT] = { { 0 } };
evt_md5_auth_data_items[analyzer_eap_common_client].name = "client";
evt_md5_auth_data_items[analyzer_eap_common_client].flags = DATA_REG_FLAG_NO_ALLOC;
evt_md5_auth_data_items[analyzer_eap_common_server].name = "server";
evt_md5_auth_data_items[analyzer_eap_common_server].flags = DATA_REG_FLAG_NO_ALLOC;
evt_md5_auth_data_items[analyzer_eap_common_top_proto].name = "top_proto";
evt_md5_auth_data_items[analyzer_eap_common_top_proto].value_type = ptype_get_type("string");
evt_md5_auth_data_items[analyzer_eap_common_vlan].name = "vlan";
evt_md5_auth_data_items[analyzer_eap_common_vlan].flags = DATA_REG_FLAG_NO_ALLOC;
evt_md5_auth_data_items[analyzer_eap_common_identifier].name = "identifier";
evt_md5_auth_data_items[analyzer_eap_common_identifier].value_type = ptype_get_type("uint8");
evt_md5_auth_data_items[analyzer_eap_common_username].name = "username";
evt_md5_auth_data_items[analyzer_eap_common_username].value_type = ptype_get_type("string");
evt_md5_auth_data_items[analyzer_eap_common_success].name = "success";
evt_md5_auth_data_items[analyzer_eap_common_success].value_type = ptype_get_type("bool");
evt_md5_auth_data_items[analyzer_eap_md5_challenge].name = "challenge";
evt_md5_auth_data_items[analyzer_eap_md5_challenge].value_type = ptype_get_type("bytes");
evt_md5_auth_data_items[analyzer_eap_md5_response].name = "response";
evt_md5_auth_data_items[analyzer_eap_md5_response].value_type = ptype_get_type("bytes");
static struct data_reg evt_md5_auth_data = {
.items = evt_md5_auth_data_items,
.data_count = ANALYZER_EAP_MD5_AUTH_DATA_COUNT
};
static struct event_reg_info analyzer_eap_evt_md5_auth = { 0 };
analyzer_eap_evt_md5_auth.source_name = "analyzer_eap";
analyzer_eap_evt_md5_auth.source_obj = analyzer;
analyzer_eap_evt_md5_auth.name = "eap_md5_auth";
analyzer_eap_evt_md5_auth.description = "PPP CHAP MD5 authentication";
analyzer_eap_evt_md5_auth.data_reg = &evt_md5_auth_data;
analyzer_eap_evt_md5_auth.listeners_notify = analyzer_eap_event_listeners_notify;
priv->evt_md5_auth = event_register(&analyzer_eap_evt_md5_auth);
if (!priv->evt_md5_auth)
goto err;
return POM_OK;
err:
analyzer_eap_cleanup(analyzer);
return POM_ERR;
}
