static int add_event_lock(enum local_event_type type, struct local_node *lnode,
void *buf, size_t buf_len)
{
int ret;
shm_queue_lock();
ret = add_event(type, lnode, buf, buf_len);
shm_queue_unlock();
return ret;
}
static int local_notify(void *msg, size_t msg_len, void (*block_cb)(void *arg))
{
shm_queue_lock();
add_event(EVENT_NOTIFY, &this_node, msg, msg_len, block_cb);
shm_queue_unlock();
return 0;
}
event_node_ptr fake_event_source::move_mouse(const size_t time, const int x, const int y)
{
SDL_Event event;
event.type = SDL_MOUSEMOTION;
event.motion.x = static_cast<Uint16>(x);
event.motion.y = static_cast<Uint16>(y);
event_node_ptr new_move(new event_node_mouse_motion(time, event));
add_event(new_move);
return new_move;
}
static int local_leave(void)
{
shm_queue_lock();
add_event(EVENT_LEAVE, &this_node, NULL, 0, NULL);
shm_queue_unlock();
return 0;
}
static int
find_event(struct pevent *pevent, struct event_list **events,
char *sys_name, char *event_name)
{
struct event_format *event;
regex_t ereg;
regex_t sreg;
int match = 0;
char *reg;
int ret;
int i;
if (!event_name) {
/* if no name is given, then swap sys and name */
event_name = sys_name;
sys_name = NULL;
}
reg = malloc_or_die(strlen(event_name) + 3);
sprintf(reg, "^%s$", event_name);
ret = regcomp(&ereg, reg, REG_ICASE|REG_NOSUB);
free(reg);
if (ret)
return -1;
if (sys_name) {
reg = malloc_or_die(strlen(sys_name) + 3);
sprintf(reg, "^%s$", sys_name);
ret = regcomp(&sreg, reg, REG_ICASE|REG_NOSUB);
free(reg);
if (ret) {
regfree(&ereg);
return -1;
}
}
for (i = 0; i < pevent->nr_events; i++) {
event = pevent->events[i];
if (event_match(event, sys_name ? &sreg : NULL, &ereg)) {
match = 1;
add_event(events, event);
}
}
regfree(&ereg);
if (sys_name)
regfree(&sreg);
if (!match)
return -1;
return 0;
}
static void add_event_all (const int event, const void *data)
{
int i;
int added = 0;
if (event == EV_STATE) {
switch (audio_get_state()) {
case STATE_PLAY:
on_song_change ();
break;
case STATE_STOP:
on_stop ();
break;
}
}
for (i = 0; i < CLIENTS_MAX; i++) {
void *data_copy = NULL;
if (clients[i].socket == -1)
continue;
if (!clients[i].wants_plist_events && is_plist_event (event))
continue;
if (data) {
if (event == EV_PLIST_ADD
|| event == EV_QUEUE_ADD) {
data_copy = plist_new_item ();
plist_item_copy (data_copy, data);
}
else if (event == EV_PLIST_DEL
|| event == EV_QUEUE_DEL
|| event == EV_STATUS_MSG
|| event == EV_SRV_ERROR) {
data_copy = xstrdup (data);
}
else if (event == EV_PLIST_MOVE
|| event == EV_QUEUE_MOVE)
data_copy = move_ev_data_dup (
(struct move_ev_data *)
data);
else
logit ("Unhandled data!");
}
add_event (&clients[i], event, data_copy);
added++;
}
if (added)
wake_up_server ();
else
debug ("No events have been added because there are no clients");
}
void h83002_device::internal_update(uint64_t current_time)
{
uint64_t event_time = 0;
add_event(event_time, adc->internal_update(current_time));
add_event(event_time, sci0->internal_update(current_time));
add_event(event_time, sci1->internal_update(current_time));
add_event(event_time, timer16_0->internal_update(current_time));
add_event(event_time, timer16_1->internal_update(current_time));
add_event(event_time, timer16_2->internal_update(current_time));
add_event(event_time, timer16_3->internal_update(current_time));
add_event(event_time, timer16_4->internal_update(current_time));
add_event(event_time, watchdog->internal_update(current_time));
recompute_bcount(event_time);
}
// 创建事件包的步骤
// 1. 使用create_params_block添加第一个参数
// 2. add_next_param直到添加完全部参数
// 3. create_event_package创建数据包，并delete_params_block来释放params_block
struct sub_device_buffer * FUNCTION_ATTRIBUTE construct_sub_device_event()
{
struct sub_device_buffer *event_buffer = NULL;
struct TLVs *params_block = NULL;
uint16_t event_num = 0x0911;
uint16_t flag = 0x0011;
uint32_t event_param1 = 0xa1b2c3d4;
uint8_t event_param2 = 0xc1;
char event_param3[] = "test data";
event_buffer = create_event_package(flag);
if (NULL == event_buffer)
{
pd_printf("Create event package failed.");
return NULL;
}
params_block = create_params_block();
if (params_block == NULL)
{
pd_printf("Create first tlv param failed.\n");
return NULL;
}
if (add_next_param(params_block, TLV_TYPE_UINT8, sizeof(event_param2), &event_param2))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
if (add_next_param(params_block, TLV_TYPE_UINT32, sizeof(event_param1), &event_param1))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
if (add_next_param(params_block, TLV_TYPE_BYTES, sizeof(event_param3), event_param3))
{
delete_params_block(params_block);
pd_printf("Add next tlv param failed.\n");
return NULL;
}
// 3. create event with flag, priority and tlv params
add_event(event_buffer, event_num, 0, params_block);
delete_params_block(params_block);
finish_package(event_buffer);
show_package(event_buffer->buffer, event_buffer->buffer_length);
return event_buffer;
}
travel_event_t::travel_event_t( action_t* a,
action_state_t* state,
timespan_t time_to_travel ) :
event_t( *a -> player ), action( a ), state( state )
{
if ( sim().debug )
sim().out_debug.printf( "New Stateless Action Travel Event: %s %s %.2f",
a -> player -> name(), a -> name(), time_to_travel.total_seconds() );
add_event( time_to_travel );
}
void radioart_init(bool entering_screen)
{
int i;
if (entering_screen)
{
for(i=0;i<MAX_RADIOART_IMAGES;i++)
{
radioart[i].handle = -1;
radioart[i].name[0] = '\0';
}
add_event(PLAYBACK_EVENT_START_PLAYBACK, true, playback_restarting_handler);
}
else
{
#if defined(HAVE_RECORDING)
add_event(RECORDING_EVENT_START, false, recording_started_handler);
add_event(RECORDING_EVENT_STOP, false, recording_stopped_handler);
#endif
}
}
int
add_muf_tread_event(int descr, dbref player, dbref prog, struct frame *fr, int delay)
{
if (!fr) {
panic("add_muf_tread_event(): NULL frame passed !");
}
FLAGS(player) |= (INTERACTIVE | READMODE);
return add_event(TQ_MUF_TYP, TQ_MUF_TREAD, delay, descr, player, -1, fr->trig,
prog, fr, "READ", NULL, NULL);
}
void Dungeon::queue_monster_turns()
{
Character *c;
for (int y = 0; y < s_instance->get_height(); y++) {
for (int x = 0; x < s_instance->get_width(); x++) {
if ((c = get_character(x, y))) {
add_event((1000 / c->get_speed()), c);
}
}
}
}
static void event_end(void)
{
struct divecomputer *dc = get_dc();
if (cur_event.name) {
if (strcmp(cur_event.name, "surface") != 0)
add_event(dc, cur_event.time.seconds,
cur_event.type, cur_event.flags,
cur_event.value, cur_event.name);
free((void *)cur_event.name);
}
cur_event.active = 0;
}
/* only copies events from the first dive computer */
void copy_events(struct dive *s, struct dive *d)
{
struct event *ev;
if (!s || !d)
return;
ev = s->dc.events;
d->dc.events = NULL;
while (ev != NULL) {
add_event(&d->dc, ev->time.seconds, ev->type, ev->flags, ev->value, ev->name);
ev = ev->next;
}
}
/* FIXME: we have to call nr of nodes times to update nodes information */
static void local_update_node(struct sd_node *node)
{
struct local_node n = {
.node = *node,
};
shm_queue_lock();
add_event(EVENT_UPDATE_NODE, &n, NULL, 0);
shm_queue_unlock();
}
void handle_accept(int epollfd, int listenfd){
int clifd;
struct sockaddr_in cliaddr;
socklen_t cliaddrlen;
clifd = accept(listenfd, (struct sockaddr*)&cliaddr, &cliaddrlen);
if(clifd == -1){
perror("accept error:");
}else{
printf("accept a new client: %s:%d\n", inet_ntoa(cliaddr.sin_addr), cliaddr.sin_port);
add_event(epollfd, clifd, EPOLLIN);
}
}
int
add_muf_timer_event(int descr, dbref player, dbref prog, struct frame *fr, int delay, char *id)
{
if (!fr) {
panic("add_muf_timer_event(): NULL frame passed !");
}
char buf[40];
snprintf(buf, sizeof(buf), "TIMER.%.32s", id);
fr->timercount++;
return add_event(TQ_MUF_TYP, TQ_MUF_TIMER, delay, descr, player, -1, fr->trig,
prog, fr, buf, NULL, NULL);
}
static int local_join(struct sd_node *myself,
void *opaque, size_t opaque_len)
{
this_node = *myself;
shm_queue_lock();
add_event(EVENT_JOIN_REQUEST, &this_node, opaque, opaque_len);
shm_queue_unlock();
return 0;
}
int serverAccept(event *v, int fd) {
char *msg;
char clientHost[32];
int clientPort, clientFd;
if ((clientFd = anetTcpAccept(msg, fd, &clientHost[0], &clientPort)) > 0) {
lookup_log(LOG_DEBUG, "accept %s:%d fd:%d\n", clientHost, clientPort, clientFd);
if (anetNonBlock(msg, clientFd) < 0) {
return -1;
}
add_event(pool, clientFd, EPOLLIN, serverRead);
}
return 0;
}
void parse(irccfg_t * info, msg_t * data)
{
if (data->sender != NULL && index(data->sender, '!') != NULL)
add_event(info->tid, data);
bot_t temp = bot_command(data->message);
if (temp.command != NULL)
{
if (strcasecmp(temp.command, "last") == 0)
{
field_t target = get_target(data);
if (temp.args == NULL)
respond(info, "PRIVMSG %s :Syntax: %slast <nickname>\n", target.field, SENTINEL);
else
{
char nick[CFG_FLD+1];
memset(nick, 0, CFG_FLD+1);
int length = strlen(temp.args);
if (index(temp.args, ' ') != NULL)
length = index(temp.args, ' ') - temp.args;
if (length > CFG_FLD) length = CFG_FLD;
strncpy(nick, temp.args, length);
find_target_last(info, nick, target.field);
}
}
if (strcasecmp(temp.command, "seen") == 0)
{
field_t target = get_target(data);
field_t snick = get_nick(data->sender);
if (temp.args == NULL)
respond(info, "PRIVMSG %s :Syntax: %sseen <nickname>\n", target.field, SENTINEL);
else
{
char nick[CFG_FLD+1];
memset(nick, 0, CFG_FLD+1);
int length = strlen(temp.args);
if (index(temp.args, ' ') != NULL)
length = index(temp.args, ' ') - temp.args;
if (length > CFG_FLD) length = CFG_FLD;
strncpy(nick, temp.args, length);
if (strcasecmp(nick, snick.field) == 0)
respond(info, "PRIVMSG %s :%s, look in a mirror\n", target.field, snick.field);
else
find_target_seen(info, nick, target.field);
}
}
}
}
void h83048_device::internal_update(UINT64 current_time)
{
UINT64 event_time = 0;
add_event(event_time, adc->internal_update(current_time));
add_event(event_time, sci0->internal_update(current_time));
add_event(event_time, sci1->internal_update(current_time));
add_event(event_time, timer16_0->internal_update(current_time));
add_event(event_time, timer16_1->internal_update(current_time));
add_event(event_time, timer16_2->internal_update(current_time));
add_event(event_time, timer16_3->internal_update(current_time));
add_event(event_time, timer16_4->internal_update(current_time));
recompute_bcount(event_time);
}
/******************************************************************************
* *
* Function: generate_events *
* *
* Purpose: Generate events for triggers after maintenance period. Events *
* will be generated if trigger value changed during maintenance. *
* *
* Parameters: hostid - host identifier from database *
* maintenance_from, maintenance_to - maintenance period bounds *
* *
******************************************************************************/
static void generate_events(zbx_uint64_t hostid, int maintenance_from, int maintenance_to)
{
const char *__function_name = "generate_events";
DB_RESULT result;
DB_ROW row;
zbx_uint64_t triggerid;
zbx_timespec_t ts;
unsigned char value_before, value_inside, value_after;
ts.sec = maintenance_to;
ts.ns = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
result = DBselect(
"select distinct t.triggerid,t.description,t.expression,t.priority,t.type,t.lastchange,t.value"
" from triggers t,functions f,items i"
" where t.triggerid=f.triggerid"
" and f.itemid=i.itemid"
" and t.status=%d"
" and i.status=%d"
" and i.state=%d"
" and i.hostid=" ZBX_FS_UI64,
TRIGGER_STATUS_ENABLED,
ITEM_STATUS_ACTIVE,
ITEM_STATE_NORMAL,
hostid);
while (NULL != (row = DBfetch(result)))
{
if (atoi(row[5]) < maintenance_from) /* if no events inside maintenance */
continue;
ZBX_STR2UINT64(triggerid, row[0]);
ZBX_STR2UCHAR(value_after, row[6]);
get_trigger_values(triggerid, maintenance_from, &value_before, &value_inside, value_after);
if (value_before == value_inside && value_inside == value_after)
continue;
add_event(0, EVENT_SOURCE_TRIGGERS, EVENT_OBJECT_TRIGGER, triggerid, &ts, value_after,
row[1], row[2], (unsigned char)atoi(row[3]), (unsigned char)atoi(row[4]));
}
DBfree_result(result);
process_events();
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: discovery_update_host_status *
* *
* Purpose: update new host status *
* *
* Author: Alexander Vladishev *
* *
******************************************************************************/
static void discovery_update_host_status(DB_DHOST *dhost, int status, int now)
{
zbx_timespec_t ts;
ts.sec = now;
ts.ns = 0;
/* update host status */
if (DOBJECT_STATUS_UP == status)
{
if (DOBJECT_STATUS_DOWN == dhost->status || 0 == dhost->lastup)
{
dhost->status = status;
dhost->lastdown = 0;
dhost->lastup = now;
discovery_update_dhost(dhost);
add_event(0, EVENT_SOURCE_DISCOVERY, EVENT_OBJECT_DHOST, dhost->dhostid, &ts,
DOBJECT_STATUS_DISCOVER, NULL, NULL, 0, 0);
}
}
else /* DOBJECT_STATUS_DOWN */
{
if (DOBJECT_STATUS_UP == dhost->status || 0 == dhost->lastdown)
{
dhost->status = status;
dhost->lastdown = now;
dhost->lastup = 0;
discovery_update_dhost(dhost);
add_event(0, EVENT_SOURCE_DISCOVERY, EVENT_OBJECT_DHOST, dhost->dhostid, &ts,
DOBJECT_STATUS_LOST, NULL, NULL, 0, 0);
}
}
add_event(0, EVENT_SOURCE_DISCOVERY, EVENT_OBJECT_DHOST, dhost->dhostid, &ts, status, NULL, NULL, 0, 0);
process_events();
}
void do_epoll(int listenfd){
int epollfd;
struct epoll_event events[EPOLLEVENTS];
int ret;
char buf[MAXSIZE];
memset(buf, 0, MAXSIZE);
epollfd = epoll_create(FDSIZE);
add_event(epollfd, listenfd, EPOLLIN);
while(1){
ret = epoll_wait(epollfd, events, EPOLLEVENTS, -1);
handle_events(epollfd, events, ret, listenfd, buf);
}
close(epollfd);
}
void data_session_close(SESSION *session)
{
TERMINAL *terminal = (TERMINAL *)session->terminal;
if (terminal->session == session) {
terminal->session = NULL;
add_event(terminal, RECORD_EVENT_TERMINAL_OFFLINE);
api_log_printf("[TR151] Connection closed, terminal_id=%u\r\n", terminal->id);
}
api_log_printf("[TR151] Closing session 0x%08X\r\n", session);
free(session);
}
static void handle_connection(int sockfd)
{
int epollfd;
struct epoll_event events[EPOLLEVENTS];
char buf[MAXSIZE];
int ret;
epollfd = epoll_create(FDSIZE);
add_event(epollfd,STDIN_FILENO,EPOLLIN);
for ( ; ; )
{
ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1);
handle_events(epollfd,events,ret,sockfd,buf);
}
close(epollfd);
}
//A delayed message saying the cards are being shuffled.
void PokerShuffle( void* Data )
{
PokerTable* Table = (PokerTable*) Data;
if( Table->GetPlayers().size() <= 1 )
{
if( Table->GetPlayers().size() == 1 )
Table->CloseTable();
delete Table;
return;
}
Table->SendToTable("The dealer shuffles the cards...\r\n");
add_event(16, PokerDeal, (void*)Table);
}
static void local_unblock(void *msg, size_t msg_len)
{
struct local_event *ev;
shm_queue_lock();
ev = shm_queue_peek_block_event();
ev->removed = true;
msync(ev, sizeof(*ev), MS_SYNC);
add_event(EVENT_NOTIFY, &this_node, msg, msg_len);
shm_queue_unlock();
}
static int local_join(const struct sd_node *myself,
void *opaque, size_t opaque_len)
{
this_node.node = *myself;
this_node.pid = getpid();
this_node.gateway = false;
shm_queue_lock();
add_event(EVENT_JOIN_REQUEST, &this_node, opaque, opaque_len);
shm_queue_unlock();
return 0;
}
void add_gas_switch_event(struct dive *dive, struct divecomputer *dc, int seconds, int idx)
{
/* The gas switch event format is insane. It will be fixed, I think */
int o2 = dive->cylinder[idx].gasmix.o2.permille;
int he = dive->cylinder[idx].gasmix.he.permille;
int value;
if (!o2)
o2 = O2_IN_AIR;
o2 = (o2+5) / 10;
he = (he+5) / 10;
value = o2 + (he << 16);
add_event(dc, seconds, 11, 0, value, "gaschange");
}
