static int wait_pri(struct pri *pri) { struct timeval *tv, real; fd_set fds; int res; FD_ZERO(&fds); FD_SET(pri->fd, &fds); tv = pri_schedule_next(pri); if (tv) { gettimeofday(&real, NULL); real.tv_sec = tv->tv_sec - real.tv_sec; real.tv_usec = tv->tv_usec - real.tv_usec; if (real.tv_usec < 0) { real.tv_usec += 1000000; real.tv_sec -= 1; } if (real.tv_sec < 0) { real.tv_sec = 0; real.tv_usec = 0; } } res = select(pri->fd + 1, &fds, NULL, NULL, tv ? &real : tv); if (res < 0) return -1; return res; }
static void *dchan(void *data) { /* Joint D-channel */ struct pri *pri = data; struct timeval *next, tv; pri_event *e; fd_set fds; int res; for(;;) { if ((next = pri_schedule_next(pri))) { gettimeofday(&tv, NULL); tv.tv_sec = next->tv_sec - tv.tv_sec; tv.tv_usec = next->tv_usec - tv.tv_usec; if (tv.tv_usec < 0) { tv.tv_usec += 1000000; tv.tv_sec -= 1; } if (tv.tv_sec < 0) { tv.tv_sec = 0; tv.tv_usec = 0; } } FD_ZERO(&fds); FD_SET(pri_fd(pri), &fds); res = select(pri_fd(pri) + 1, &fds, NULL, NULL, next ? &tv : NULL); pthread_mutex_lock(&lock); cur = pri; if (res < 0) { perror("select"); } else if (!res) { e = pri_schedule_run(pri); } else { e = pri_check_event(pri); } if (e) { if (first == pri) { event1(pri, e); } else { event2(pri, e); } } pthread_mutex_unlock(&lock); } return NULL; }
int lpwrap_one_loop(struct lpwrap_pri *spri) { fd_set rfds, efds; struct timeval now = {0,0}, *next; pri_event *event; event_handler handler; int sel; if (spri->on_loop) { if ((sel = spri->on_loop(spri)) < 0) { return sel; } } if (spri->errs >= 2) { spri->errs = 0; return -1; } FD_ZERO(&rfds); FD_ZERO(&efds); #ifdef _MSC_VER //Windows macro for FD_SET includes a warning C4127: conditional expression is constant #pragma warning(push) #pragma warning(disable:4127) #endif FD_SET(pri_fd(spri->pri), &rfds); FD_SET(pri_fd(spri->pri), &efds); #ifdef _MSC_VER #pragma warning(pop) #endif now.tv_sec = 0; now.tv_usec = 100000; sel = select(pri_fd(spri->pri) + 1, &rfds, NULL, &efds, &now); event = NULL; if (!sel) { if ((next = pri_schedule_next(spri->pri))) { gettimeofday(&now, NULL); if (now.tv_sec >= next->tv_sec && (now.tv_usec >= next->tv_usec || next->tv_usec <= 100000)) { //zap_log(ZAP_LOG_DEBUG, "Check event\n"); event = pri_schedule_run(spri->pri); } } } else if (sel > 0) { event = pri_check_event(spri->pri); } if (event) { /* 0 is catchall event handler */ if ((handler = spri->eventmap[event->e] ? spri->eventmap[event->e] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) { handler(spri, event->e, event); } else { zap_log(ZAP_LOG_CRIT, "No event handler found for event %d.\n", event->e); } } return sel; if ((handler = spri->eventmap[LPWRAP_PRI_EVENT_IO_FAIL] ? spri->eventmap[LPWRAP_PRI_EVENT_IO_FAIL] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) { handler(spri, LPWRAP_PRI_EVENT_IO_FAIL, NULL); } return -1; }
int sangoma_one_loop(struct sangoma_pri *spri) { fd_set rfds, efds; struct timeval now = {0,0}, *next; pri_event *event; int sel; if (spri->on_loop) { spri->on_loop(spri); } FD_ZERO(&rfds); FD_ZERO(&efds); #ifdef _MSC_VER //Windows macro for FD_SET includes a warning C4127: conditional expression is constant #pragma warning(push) #pragma warning(disable:4127) #endif FD_SET(spri->pri->fd, &rfds); FD_SET(spri->pri->fd, &efds); #ifdef _MSC_VER #pragma warning(pop) #endif if ((next = pri_schedule_next(spri->pri))) { gettimeofday(&now, NULL); now.tv_sec = next->tv_sec - now.tv_sec; now.tv_usec = next->tv_usec - now.tv_usec; if (now.tv_usec < 0) { now.tv_usec += 1000000; now.tv_sec -= 1; } if (now.tv_sec < 0) { now.tv_sec = 0; now.tv_usec = 0; } } sel = select(spri->pri->fd + 1, &rfds, NULL, &efds, next ? &now : NULL); event = NULL; if (!sel) { event = pri_schedule_run(spri->pri); } else if (sel > 0) { event = pri_check_event(spri->pri); } if (event) { event_handler handler; /* 0 is catchall event handler */ if ((handler = spri->eventmap[event->e] ? spri->eventmap[event->e] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) { handler(spri, event->e, event); } else { fprintf(stderr,"No event handler found for event %d.\n", event->e); } } return sel; }
static int run_pri(int dfd, int swtype, int node) { struct pri *pri; pri_event *e; struct timeval tv = {0,0}, *next; fd_set rfds, efds; int res,x; pri = pri_new_bri(dfd, 1, node, swtype); if (!pri) { fprintf(stderr, "Unable to create PRI\n"); return -1; } pri_set_debug(pri, -1); for (;;) { /* Run the D-Channel */ FD_ZERO(&rfds); FD_ZERO(&efds); FD_SET(dfd, &rfds); FD_SET(dfd, &efds); if ((next = pri_schedule_next(pri))) { gettimeofday(&tv, NULL); tv.tv_sec = next->tv_sec - tv.tv_sec; tv.tv_usec = next->tv_usec - tv.tv_usec; if (tv.tv_usec < 0) { tv.tv_usec += 1000000; tv.tv_sec -= 1; } if (tv.tv_sec < 0) { tv.tv_sec = 0; tv.tv_usec = 0; } } res = select(dfd + 1, &rfds, NULL, &efds, next ? &tv : NULL); e = NULL; if (!res) { e = pri_schedule_run(pri); } else if (res > 0) { e = pri_check_event(pri); } else if (errno == ELAST) { res = ioctl(dfd, ZT_GETEVENT, &x); printf("Got Zaptel event: %d\n", x); } else if (errno != EINTR) fprintf(stderr, "Error (%d) on select: %s\n", ELAST, strerror(errno)); if (e) { handle_pri_event(pri, e); } res = ioctl(dfd, ZT_GETEVENT, &x); if (!res && x) { fprintf(stderr, "Got event on PRI interface: %d\n", x); } /* Check for lines that need hangups */ for (x=0;x<MAX_CHAN;x++) if (chans[x].needhangup) { chans[x].needhangup = 0; pri_release(pri, chans[x].call, PRI_CAUSE_NORMAL_CLEARING); } } return 0; }
int sangoma_one_loop(struct sangoma_pri *spri) { fd_set rfds; // we dont need efds unless we want to handle span alarms // right now sbridge does not makes calls, so there is no point // in handling alarms //fd_set efds; struct timeval now = {0,0}, *next; pri_event *event; int sel; sbridge_mutex_lock(&spri->lock); if (spri->on_loop) { spri->on_loop(spri); } FD_ZERO(&rfds); //FD_ZERO(&efds); #ifdef _MSC_VER //Windows macro for FD_SET includes a warning C4127: conditional expression is constant #pragma warning(push) #pragma warning(disable:4127) #endif FD_SET(pri_fd(spri->pri), &rfds); //FD_SET(pri_fd(spri->pri), &efds); #ifdef _MSC_VER #pragma warning(pop) #endif if ((next = pri_schedule_next(spri->pri))) { gettimeofday(&now, NULL); now.tv_sec = next->tv_sec - now.tv_sec; now.tv_usec = next->tv_usec - now.tv_usec; if (now.tv_usec < 0) { now.tv_usec += 1000000; now.tv_sec -= 1; } if (now.tv_sec < 0) { now.tv_sec = 0; now.tv_usec = 0; } } sbridge_mutex_unlock(&spri->lock); //sel = select(pri_fd(spri->pri) + 1, &rfds, NULL, &efds, next ? &now : NULL); sel = select(pri_fd(spri->pri) + 1, &rfds, NULL, NULL, next ? &now : NULL); sbridge_mutex_lock(&spri->lock); event = NULL; if (!sel) { event = pri_schedule_run(spri->pri); } else if (sel > 0) { event = pri_check_event(spri->pri); } else if (errno != EINTR){ sbridge_log(SBRIDGE_LOG_ERROR, "select failed: %s\n", sbridge_os_get_last_error()); } else { /* at this point we know there is a select error and is EINTR, ignore */ sel = 0; } if (event) { event_handler handler; /* 0 is catchall event handler */ const int eventmap_size = sizeof(spri->eventmap)/sizeof(spri->eventmap[0]); if (eventmap_size <= event->e) { sbridge_log(SBRIDGE_LOG_ERROR, "Event %d is too big, we did not expect it!.\n", event->e); } else { if ((handler = spri->eventmap[event->e] ? spri->eventmap[event->e] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) { handler(spri, event->e, event); } else { sbridge_log(SBRIDGE_LOG_ERROR, "No event handler found for event %d.\n", event->e); } } } sbridge_mutex_unlock(&spri->lock); return sel; }