// 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; }