int neighbor_start_inactive_timer(struct ospfd *ospfd,
struct interface_data *i, struct neighbor *neighbor)
{
int ret;
struct inactivity_timer_data *inactivity_timer_data;
/* FIXME: hardcoded time-out */
struct timespec timespec = { 10, 0 };
struct ev_entry *ev_entry;
msg(ospfd, DEBUG, "prepare inactive timer for neighbor");
inactivity_timer_data = xzalloc(sizeof(struct inactivity_timer_data));
inactivity_timer_data->ospfd = ospfd;
inactivity_timer_data->neighbor = neighbor;
inactivity_timer_data->interface_data = i;
neighbor->inactivity_timer_data = inactivity_timer_data;
ev_entry = ev_timer_new(×pec, neighbor_inactive_timer_expired,
inactivity_timer_data);
if (!ev_entry) {
err_msg_die(EXIT_FAILURE, "Cannot initialize a new timer");
}
inactivity_timer_data->neighbor->inactive_timer_entry = ev_entry;
ret = ev_add(ospfd->ev, ev_entry);
if (ret != EV_SUCCESS) {
err_msg_die(EXIT_FAILURE, "Cannot add new timer to global event handler");
}
return SUCCESS;
}
void enqueue_eventdesc(at *handler, int event,
int xd, int yd, int xu, int yu, char *desc)
{
int mods = -1;
at *ev = event_to_list(event, xd, yd, xu, yu, &mods);
if (!ev) return;
ev_add(handler, ev, desc, mods);
}
/* event_add --
* Add a new event targeted to a specific handler.
*/
void event_add(at *handler, at *event)
{
if (!handler)
RAISEF("invalid event handler", handler);
if (!CONSP(event))
RAISEF("invalid event (not a list expected)", event);
ev_add(handler, event, NULL, -1);
}
int main(int argc, char *argv[]){
int sfd;
sfd = tcpsock_create();
sock_setopt(sfd);
sock_listen(sfd, SERVER_PORT, BACKLOG);
fd_setnb(sfd);
int evfd;
evfd = ev_create();
ev_add(evfd, sfd, EV_IN);
struct ev_event events[MAX_EVENT];
int n;
int i;
int cfd;
unsigned char buf[BUF_SIZE];
ssize_t rbytes;
while(1) {
n = ev_wait(evfd, events, MAX_EVENT, -1);
printf("%d\n", n);
for(i=0; i < n; i++){
printf("%d, %d, %d, %d, %d\n", events[i].events, events[i].fd, events[i].readable, events[i].writable, events[i].closable);
if (events[i].fd == sfd) {
while(1) {
cfd = sock_accept(sfd);
if (cfd == -1) {
break;
}
fd_setnb(cfd);
ev_add(evfd, cfd, EV_IN);
}
} else if (events[i].closable == true) {
close(events[i].fd);
} else if (events[i].readable == true) {
while(1) {
rbytes = sock_recv(events[i].fd, buf, BUF_SIZE);
if (rbytes == -1) {
break;
}
buf[rbytes] = '\0';
printf("%s", buf);
}
}
}
}
}
/* event_add --
Add a new event targeted to a specific handler.
*/
void
event_add(at *handler, at *event)
{
if (! handler)
error(NIL,"Illegal null event handler",NIL);
if (! CONSP(event))
error(NIL,"Illegal event expression (list expected)", event);
ev_add(handler, event, NULL, -1);
}
int init_network(struct ospfd *ospfd)
{
int ret;
struct ev_entry *ee;
switch (ospfd->opts.family) {
case AF_INET:
ret = init_raw_4_socket(ospfd);
if (ret != SUCCESS) {
err_msg("Failed to initialize raw socket");
return FAILURE;
}
/* and register fd */
ee = ev_entry_new(ospfd->network.fd, EV_READ, packet_input, ospfd);
if (!ee) {
err_msg("cannot at RAW socket to event mechanism");
return FAILURE;
}
ret = ev_add(ospfd->ev, ee);
if (ret != EV_SUCCESS) {
err_msg("cannot at RAW socket to event mechanism");
return FAILURE;
}
break;
default:
err_msg("Protocol family not supported (%d)", ospfd->opts.family);
return FAILURE;
}
ret = get_interface_addr(ospfd);
if (ret != SUCCESS) {
err_msg("failed to determine interface addresses");
return FAILURE;
}
return SUCCESS;
}
static PyObject* pyext_epoll_register(PyObject *self,PyObject *args){
int ret;
khiter_t hit;
int epfd;
int fd;
uint32_t events;
struct pyep_data *pyep;
struct ev_header *evhdr;
if(!PyArg_ParseTuple(args,"iiI",&epfd,&fd,&events)){
PyErr_BadArgument();
return NULL;
}
if((pyep = pyep_getby_epfd(epfd)) == NULL){
PyErr_SetString(PyExc_KeyError,"epoll file descriptor not found");
return NULL;
}
if((evhdr = malloc(sizeof(*evhdr))) == NULL){
return PyErr_NoMemory();
}
evhdr->fd = fd;
evhdr->handler = NULL;
if(ev_add(&pyep->evdata,evhdr,events)){
PyErr_SetString(PyExc_SystemError,"register event failed");
return NULL;
}
hit = kh_put(ptr,pyep->evhdr_ht,fd,&ret);
kh_value(pyep->evhdr_ht,hit) = evhdr;
Py_INCREF(Py_None);
return Py_None;
}
