int main( int argc, char **argv)
{
int rcvid;
struct my_msg msg;
name_attach_t *attach;
/* attach the name the client will use to find us */
/* our channel will be in the attach structure */
if ( (attach = name_attach( NULL, MY_SERV, 0 )) == NULL) // register a name in the namespace and create a channel
{
printf("server: failed to attach name, errno: %d\n", errno );
exit(1);
}
/* wait for the message from the client */
rcvid = MsgReceive( attach->chid, &msg, sizeof( msg ), NULL );
if ( msg.type == MSG_GIVE_PULSE )
{
/* wait until it is time to notify the client */
sleep(2);
/* deliver notification to client that client requested */
MsgDeliverEvent( rcvid, &msg.event );
printf("server: delivered event\n");
} else
{
printf("server: unexpected message\n");
}
return 0;
}
void* IDSEXT::idsEventThread(void *args)
{
IDSEXT *idsExt = reinterpret_cast<IDSEXT *>(args);
struct _pulse msg;
eventCHID = ChannelCreate(_NTO_CHF_COID_DISCONNECT);
while ( idsExt->connected ) {
if (MsgReceive(eventCHID, &msg, sizeof(msg), NULL) == 0) {
// Find provider - process msg
ids_provider_mapping* current = idsExt->providers;
while ( current != NULL ) {
if ( msg.code == current->providerFd ) {
// Re-arm ionotify
if (ids_process_msg(current->providerFd) != IDS_SUCCESS) {
fprintf(stderr, "Failed to process IDS message\n");
idsExt->removeProvider(current->providerFd);
} else {
if (ionotify(current->providerFd, _NOTIFY_ACTION_POLLARM, _NOTIFY_COND_INPUT, current->sigEvent) & _NOTIFY_COND_INPUT) {
MsgDeliverEvent(0, current->sigEvent);
}
}
}
current = current->next;
}
}
}
pthread_detach(pthread_self());
return NULL;
}
std::string IDSEXT::RegisterProvider(const std::string& providerName)
{
Json::FastWriter writer;
Json::Value resultJSON;
ids_provider_mapping *registeredItem = reinterpret_cast<ids_provider_mapping *>(malloc(sizeof(ids_provider_mapping)));
if (!registeredItem) {
fprintf(stderr, "Unable to register IDS provider - malloc error\n");
return "";
}
registeredItem->providerName = strdup(providerName.c_str());
resultJSON["result"] = ids_register_provider(registeredItem->providerName, ®isteredItem->provider, ®isteredItem->providerFd);
if ( (ids_result_t) resultJSON["result"].asInt() == IDS_SUCCESS ) {
registeredItem->next = providers;
providers = registeredItem;
registeredItem->sigEvent = new sigevent;
registeredItem->sigEvent->sigev_notify = SIGEV_PULSE;
registeredItem->sigEvent->sigev_coid = ConnectAttach(ND_LOCAL_NODE, 0, eventCHID, _NTO_SIDE_CHANNEL, 0);
registeredItem->sigEvent->sigev_priority = getprio(0);
registeredItem->sigEvent->sigev_code = registeredItem->providerFd;
registeredItem->sigEvent->sigev_value.sival_int = registeredItem->providerFd;
if (ionotify(registeredItem->providerFd, _NOTIFY_ACTION_POLLARM, _NOTIFY_COND_INPUT, registeredItem->sigEvent) & _NOTIFY_COND_INPUT) {
MsgDeliverEvent(0, registeredItem->sigEvent);
}
} else {
resultJSON["errno"] = strerror(errno);
}
std::string resultStr = writer.write(resultJSON);
return( resultStr.c_str() );
}
static int drain_and_arm_mmr_events(mmr_context_t *ctxt) {
const mmr_event_t *ev = mmr_event_get(ctxt);
int rc;
while (ev != NULL && ev->type != MMR_EVENT_NONE) {
ev = mmr_event_get(ctxt);
}
if (NULL == ev) {
return EXIT_FAILURE;
}
rc = mmr_event_arm(ctxt, &mmr_sigevent);
if (rc < 0) {
//errno has been set by mmr_event_arm; just return failure
return EXIT_FAILURE;
} else if (rc > 0) {
//event is already available, manually arm
MsgDeliverEvent(0, &mmr_sigevent);
}
//reach here if rc >= 0
return EXIT_SUCCESS;
}
void
iofunc_notify_trigger_strict(resmgr_context_t *ctp, iofunc_notify_t *nop, int cnt, int index) {
iofunc_notify_event_t *nep;
// Trigger all events which have a trigger cnt.
nop += index;
nop->cnt = INT_MAX;
for(nep = nop->list ; nep ; nep = nep->next) {
/* SIGEV_NONE also implies nep->cnt == INT_MAX */
if(SIGEV_GET_TYPE(&nep->event) == SIGEV_NONE)
continue;
if((ctp == NULL || (ctp->info.scoid == nep->scoid &&
ctp->info.coid == nep->coid)) && nep->cnt <= cnt) {
if(SIGEV_GET_TYPE(&nep->event) >= SIGEV_SIGNAL &&
SIGEV_GET_TYPE(&nep->event) <= SIGEV_PULSE &&
nep->event.sigev_code == SI_NOTIFY) {
nep->event.sigev_value.sival_int |= _NOTIFY_COND_INPUT << index;
if(nep->flags & _NOTIFY_COND_EXTEN) {
nep->event.sigev_value.sival_int |= _NOTIFY_COND_EXTEN;
/*
* Don't have enough bits in sival_int for
* extended flags. If they've asked for
* the extended events, it means they're
* expecting the code to be overwritten.
*/
nep->event.sigev_code = -(_NOTIFY_CONDE_RDNORM << index);
}
}
(void)MsgDeliverEvent(nep->rcvid, &nep->event);
nep->event.sigev_notify = SIGEV_NONE;
nep->cnt = INT_MAX;
}
// Calculate a new min cnt on the fly for the interrupt handler.
if(nop->cnt > nep->cnt)
nop->cnt = nep->cnt;
}
}
static int mmr_sigevent_handler(void *p) {
int rc;
mmr_context_t *ctxt = (mmr_context_t *)p;
if (NULL == p) {
show_dialog_message("mmr context error\n");
return EXIT_FAILURE;
}
const mmr_event_t *mmr_event = mmr_event_get( ctxt );
if (NULL == mmr_event) {
show_dialog_message("mmr event error\n");
return EXIT_FAILURE;
}
static mmr_state_t last_state = MMR_EVENT_NONE;
static int last_speed = 0;
if ((last_state != mmr_event->state) || (last_speed != mmr_event->speed)) {
last_state = mmr_event->state;
last_speed = mmr_event->speed;
switch (mmr_event->state) {
case MMR_STATE_PLAYING:
if (0 == mmr_event->speed)
show_dialog_message("MMRenderer Status: Pausing\n");
else
show_dialog_message("MMRenderer Status: Playing\n");
break;
case MMR_STATE_STOPPED:
show_dialog_message("MMRenderer Status: Stopped\n");
break;
case MMR_STATE_IDLE:
show_dialog_message("MMRenderer Status: Idle\n");
break;
case MMR_STATE_DESTROYED:
show_dialog_message("MMRenderer Status: Destroyed\n");
break;
default:
show_dialog_message("MMRenderer Status: Unknown\n");
break;
}
}
if ((MMR_EVENT_ERROR == mmr_event->type) && (MMR_STATE_STOPPED == mmr_event->state)){
/*
* We have reached the end. Do not rearm. Return failure to signal we
* don't want to be recalled.
*/
show_dialog_message("MMRenderer Status: No more data\n");
return EXIT_FAILURE;
}
rc = mmr_event_arm(ctxt, &mmr_sigevent);
if ( rc > 0) {
//event is already available, manually arm
MsgDeliverEvent(0, &mmr_sigevent);
} else if ( rc < 0 ) {
show_dialog_message("mmr_event_arm() error\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void *worker(void *v) {
wrk_info_t wrk_info = *(wrk_info_t*)v;
int result;
struct sigevent clientevent, timeoutevent;
struct sigaction timeoutact;
iov_t *piov, header;
frame_t frame;
timer_t timer;
syncsig_t *psync = &wrk_info.psync[wrk_info.id];
struct itimerspec timeout, stoptimeout;
struct timespec slp;
slp.tv_nsec = 10000000;
slp.tv_sec = 0;
timeout.it_interval.tv_sec = 0;
timeout.it_interval.tv_nsec = 0;
timeout.it_value.tv_sec = 0;
timeout.it_value.tv_nsec = 0;
stoptimeout = timeout;
sem_init(&psync->sem, 0, 1);
SETIOV(&header, &frame, sizeof(frame_t));
SIGEV_SIGNAL_VALUE_INIT(&timeoutevent, SIGUSR1, psync);
//SIGEV_SIGNAL_INIT(&timeoutevent, SIGUSR1) ;
__ERROR_CHECK(timer_create(CLOCK_MONOTONIC, &timeoutevent, &timer),-1,"timer_create");
__ERROR_CHECK(signal(SIGUSR1, wrk_sigusr1),-1,"signal");
//timeoutact.sa_handler = &wrk_sigusr1;
//sigaction(SIGUSR1, &timeoutact, NULL);
while(true) {
psync->rcvid = -1;
wrk_info.psync[wrk_info.id].status = READY;
psync->rcvid = MsgReceivev(wrk_info.chid, &header, 1, NULL);
__ERROR_CONT(psync->rcvid, -1, MSG_ERR_MSGREC);
wrk_info.psync[wrk_info.id].status = WORK;
if(0 == psync->rcvid) {
switch(frame.header.code) {
case _PULSE_CODE_DISCONNECT:
printf("Client has gone\n");
break;
case _PULSE_CODE_UNBLOCK:
printf("_PULSE_CODE_UNBLOCK\n");
for(size_t i=0; i<wrk_info.wrk_amount; ++i) {
if(wrk_info.psync[i].rcvid == frame.header.value.sival_int) {
if(wrk_info.psync[i].status != SEND) {
__ERROR_CHECK(MsgError(frame.header.value.sival_int, ETIME),-1,MSG_ERR_MSGERR);
}
break;
}
}
break;
default:
break;
}
} else {
if (frame.header.type == _IO_CONNECT) {
printf("Send OK\n");
frame_reply(psync->rcvid, NULL);
continue;
}
wrk_info.proute[frame.cid] = wrk_info.id;
timeout.it_value = frame.timeout;
//printf("%u %u\n", timeout.it_value.tv_sec, timeout.it_value.tv_nsec);
sem_wait(&psync->sem);
if(frame.protocol != REPLY) {
__ERROR_CHECK(timer_settime(timer, 0, &timeout, NULL),-1,"timer_settime");
}
//printf("Thread %i, client %i\n", wrk_info.id, frame.cid);
frame_datareceive(psync->rcvid, &frame);
sem_post(&psync->sem);
//sleep(1);
nanosleep( &slp, NULL);
if(frame.protocol == NOREPLY) {
SIGEV_PULSE_INIT( &clientevent, frame.coid,
SIGEV_PULSE_PRIO_INHERIT, PULSE_CODE_DATA_READY, 0);
frame_reply(psync->rcvid, NULL);
}
if(frame.protocol != REPLY) {
frame_repinit(&frame, &wrk_info.pcash[frame.cid].framerep);
for(size_t i=0; i<frame.size; ++i) {
processtask(frame.ptask+i, wrk_info.pcash[frame.cid].framerep.ptask+i,
&wrk_info.pcash[frame.cid].spline);
}
__ERROR_CHECK(timer_settime(timer, 0, &stoptimeout, NULL),-1,"timer_settime");
}
wrk_info.psync[wrk_info.id].status = SEND;
if(frame.protocol == NOREPLY) {
result = -1;
for(int i=0; i<3 && result == -1; ++i) {
result = MsgDeliverEvent(psync->rcvid, &clientevent);
__ERROR_CHECK(result, -1, "MsgDeliverEvent");
}
} else {
frame_reply(psync->rcvid, &wrk_info.pcash[frame.cid].framerep);
frame_destroy(&wrk_info.pcash[frame.cid].framerep);
}
}
}
}
