void unpause_idle_timer(void)
{
debug("entry");
assert(gRunLoop);
assert(gTimer);
CFRunLoopAddTimer(gRunLoop, gTimer, kCFRunLoopDefaultMode);
}
void
rwsched_cfrunloop_relocate_timers_to_main_mode(rwsched_tasklet_ptr_t sched_tasklet)
{
//unsigned int i, j;
unsigned int i;
rwsched_CFRunLoopTimerRef rwsched_object;
rwsched_instance_ptr_t instance;
// Validate input parameters
RW_CF_TYPE_VALIDATE(sched_tasklet, rwsched_tasklet_ptr_t);
for (i = 1 ; i < sched_tasklet->cftimer_array->len ; i++) {
if ((rwsched_object = g_array_index(sched_tasklet->cftimer_array, rwsched_CFRunLoopTimerRef, i)) != NULL) {
RW_CF_TYPE_VALIDATE(rwsched_object, rwsched_CFRunLoopTimerRef);
instance = rwsched_object->callback_context.instance;
RW_CF_TYPE_VALIDATE(instance, rwsched_instance_ptr_t);
//CFRunLoopRemoveTimer(rwsched_tasklet_CFRunLoopGetCurrent(sched_tasklet), rwsched_object->cf_object, instance->deferred_cfrunloop_mode);
if (rwsched_object->onetime_timer_fired_while_blocked) {
//(rwsched_object->cf_callout)(rwsched_object, rwsched_object->cf_context.info);
RW_ASSERT(rwsched_object->onetime_timer);
rwsched_object->cf_object = CFRunLoopTimerCreate(rwsched_object->ott.allocator,
CFAbsoluteTimeGetCurrent()+0.000001,
0,
rwsched_object->ott.flags,
rwsched_object->ott.order,
rwsched_cftimer_callout_intercept,
&rwsched_object->tmp_context);
rwsched_object->onetime_timer_fired_while_blocked = 0;
}
CFRunLoopAddTimer(rwsched_tasklet_CFRunLoopGetCurrent(sched_tasklet), rwsched_object->cf_object, instance->main_cfrunloop_mode);
}
}
}
int
timer_callout_set(timer_callout_t * callout,
CFAbsoluteTime relative_time, timer_func_t * func,
void * arg1, void * arg2, void * arg3)
{
CFRunLoopTimerContext context = { 0, NULL, NULL, NULL, NULL };
CFAbsoluteTime wakeup_time;
if (callout == NULL) {
return (0);
}
timer_cancel(callout);
if (func == NULL) {
return (0);
}
callout->func = func;
callout->arg1 = arg1;
callout->arg2 = arg2;
callout->arg3 = arg3;
callout->enabled = TRUE;
callout->time_generation = S_time_generation;
context.info = callout;
wakeup_time = CFAbsoluteTimeGetCurrent() + relative_time;
callout->timer_source
= CFRunLoopTimerCreate(NULL, wakeup_time,
0.0, 0, 0,
timer_callout_process,
&context);
my_log(LOG_DEBUG, "timer: wakeup time is (%0.09g) %0.09g",
relative_time, wakeup_time);
my_log(LOG_DEBUG, "timer: adding timer source");
CFRunLoopAddTimer(CFRunLoopGetCurrent(), callout->timer_source,
kCFRunLoopDefaultMode);
return (1);
}
int main (int argc, char * const argv[])
{
g_MasterLoop = CFRunLoopGetCurrent();
signal (SIGTERM, CancelExec);
signal (SIGHUP, ForceStartup);
signal (SIGALRM, ForceInventory);
// a bit of runway for network services
sleep(30);
CheckRun(true); // initial check
CFAuto<CFRunLoopTimerRef> SCATimer;
SCATimer.Attach(
CFRunLoopTimerCreate(
kCFAllocatorDefault,
CFAbsoluteTimeGetCurrent() + SurveyTime,
SurveyTime,
0, 0,
InventoryCheckTimerFunc,
NULL));
CFRunLoopAddTimer(g_MasterLoop, SCATimer, kCFRunLoopDefaultMode);
CFRunLoopRun();
CFRunLoopTimerInvalidate( SCATimer );
}
void fx_setTimeout(txMachine* the)
{
txTimeoutData* data;
#if mxMacOSX
CFRunLoopTimerContext context;
#endif
txNumber duration = fxToNumber(the, mxArgv(1)) / 1000;
data = c_malloc(sizeof(txTimeoutData));
mxElseError(data);
c_memset(data, 0, sizeof(txTimeoutData));
data->the = the;
data->function.kind = mxArgv(0)->kind;
data->function.value = mxArgv(0)->value;
fxRemember(the, &(data->function));
if (mxArgc > 2) {
data->argument.kind = mxArgv(2)->kind;
data->argument.value = mxArgv(2)->value;
}
fxRemember(the, &(data->argument));
#if mxMacOSX
memset(&context, 0, sizeof(context));
context.info = data;
context.release = fx_setTimeoutRelease;
data->timer = CFRunLoopTimerCreate(kCFAllocatorDefault, CFAbsoluteTimeGetCurrent() + duration, 0, 0, 0, fx_setTimeoutCallback, &context);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), data->timer, gxRunLoopMode);
#endif
}
static void
configuration_changed(SCDynamicStoreRef store, CFArrayRef changedKeys, void *info)
{
CFRunLoopTimerContext context = { 0, (void *)store, CFRetain, CFRelease, NULL };
CFAbsoluteTime time_boot;
CFAbsoluteTime time_now ;
// if active, cancel any in-progress attempt to resolve the primary IP address
if (ptrTarget != NULL) {
ptr_query_stop();
}
// if active, cancel any queued configuration change
if (timer != NULL) {
CFRunLoopTimerInvalidate(timer);
CFRelease(timer);
timer = NULL;
}
// queue configuration change
time_boot = boottime() + SMB_STARTUP_DELAY;
time_now = CFAbsoluteTimeGetCurrent() + SMB_DEBOUNCE_DELAY;
timer = CFRunLoopTimerCreate(NULL,
time_now > time_boot ? time_now : time_boot,
0,
0,
0,
smb_update_configuration,
&context);
CFRunLoopAddTimer(rl, timer, kCFRunLoopDefaultMode);
return;
}
void CFRunLoopAddMIDIRunLoopSource( CFRunLoopRef rl, struct CFMIDIRunLoopSource * source, CFStringRef mode ) {
int i;
if( source->cfrlt != NULL ) CFRunLoopAddTimer( rl, source->cfrlt, mode );
for( i=0; i<source->length; i++ ) {
if( source->cfrls[i] != NULL ) CFRunLoopAddSource( rl, source->cfrls[i], mode );
}
}
void runLoop(TimerCallbackParameters* timerCallbackParameters, float frequency)
{
CFRunLoopObserverContext observerContext;
observerContext.version = 0;
observerContext.info = 0;
observerContext.retain = 0;
observerContext.release = 0;
observerContext.copyDescription = 0;
auto observer = CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopBeforeTimers, true, 0, observerCallback, &observerContext);
CFRunLoopAddObserver(CFRunLoopGetCurrent(), observer, kCFRunLoopCommonModes);
CFRunLoopTimerContext timerContext;
timerContext.version = 0;
timerContext.info = timerCallbackParameters;
timerContext.retain = 0;
timerContext.release = 0;
timerContext.copyDescription = 0;
auto timer = CFRunLoopTimerCreate(kCFAllocatorDefault,
CFAbsoluteTimeGetCurrent(),
1.0 / frequency,
0, 0,
timerCallBack,
&timerContext);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopCommonModes);
CFRunLoopRun();
}
void* RunLoopThread(void* args)
{
unsigned i;
InitUSB();
currentRunLoop = CFRunLoopGetCurrent();
CFRunLoopTimerContext context = {0, NULL, NULL, NULL, NULL};
CFRunLoopTimerRef timer = CFRunLoopTimerCreate(kCFAllocatorDefault, 0.1, 0.1, 0, 0, &onTimerFired, &context);
CFRunLoopAddTimer(currentRunLoop, timer, kCFRunLoopCommonModes);
// Signal the parent that we are running
adb_mutex_lock(&start_lock);
adb_cond_signal(&start_cond);
adb_mutex_unlock(&start_lock);
CFRunLoopRun();
currentRunLoop = 0;
for (i = 0; i < vendorIdCount; i++) {
IOObjectRelease(notificationIterators[i]);
}
IONotificationPortDestroy(notificationPort);
usb_cleanup();
DBG("RunLoopThread done\n");
return NULL;
}
void HeapTimer::synchronize()
{
if (CFRunLoopGetCurrent() == m_runLoop.get())
return;
CFRunLoopRemoveTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes);
m_runLoop = CFRunLoopGetCurrent();
CFRunLoopAddTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes);
}
void DefaultGCActivityCallback::synchronize()
{
if (CFRunLoopGetCurrent() == d->runLoop.get())
return;
CFRunLoopRemoveTimer(d->runLoop.get(), d->timer.get(), kCFRunLoopCommonModes);
d->runLoop = CFRunLoopGetCurrent();
CFRunLoopAddTimer(d->runLoop.get(), d->timer.get(), kCFRunLoopCommonModes);
}
static void
schedulePowerEvent(PowerEventBehavior *behave)
{
static CFRunLoopTimerContext tmr_context = {0,0,0,0,0};
CFAbsoluteTime fire_time = 0.0;
CFDictionaryRef upcoming = NULL;
CFDateRef temp_date = NULL;
if(behave->timer)
{
CFRunLoopTimerInvalidate(behave->timer);
CFRelease(behave->timer);
behave->timer = 0;
}
// find upcoming time
upcoming = copyEarliestUpcoming(behave);
if(!upcoming)
{
// No scheduled events
if (behave->noScheduledEventCallout) {
(*behave->noScheduledEventCallout)(NULL);
}
return;
}
/*
* Perform any necessary actions at schedulePowerEvent time
*/
if ( behave->scheduleNextCallout ) {
(*behave->scheduleNextCallout)(upcoming);
}
if (behave->currentEvent) {
CFRelease(behave->currentEvent);
}
behave->currentEvent = (CFDictionaryRef)upcoming;
tmr_context.info = (void *)behave;
temp_date = _getScheduledEventDate(upcoming);
if(!temp_date) goto exit;
fire_time = CFDateGetAbsoluteTime(temp_date);
behave->timer = CFRunLoopTimerCreate(0, fire_time, 0.0, 0,
0, handleTimerExpiration, &tmr_context);
if(behave->timer)
{
CFRunLoopAddTimer( CFRunLoopGetCurrent(),
behave->timer,
kCFRunLoopDefaultMode);
}
exit:
return;
}
void cfRunLoopRun(ExternalTimerCallback callback, void* context) {
externalCallback = callback;
externalContext = context;
timerRef = CFRunLoopTimerCreate(NULL, 0, 1.0, 0, 0, timerCallback, NULL);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timerRef, kCFRunLoopCommonModes);
CFRunLoopRun();
}
HeapTimer::HeapTimer(JSGlobalData* globalData, CFRunLoopRef runLoop)
: m_globalData(globalData)
, m_runLoop(runLoop)
{
memset(&m_context, 0, sizeof(CFRunLoopTimerContext));
m_context.info = this;
m_timer.adoptCF(CFRunLoopTimerCreate(0, s_decade, s_decade, 0, 0, HeapTimer::timerDidFire, &m_context));
CFRunLoopAddTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes);
}
void RunLoop::TimerBase::start(double nextFireInterval, bool repeat)
{
if (m_timer)
stop();
CFRunLoopTimerContext context = { 0, this, 0, 0, 0 };
CFTimeInterval repeatInterval = repeat ? nextFireInterval : 0;
m_timer = adoptCF(CFRunLoopTimerCreate(kCFAllocatorDefault, CFAbsoluteTimeGetCurrent() + nextFireInterval, repeatInterval, 0, 0, timerFired, &context));
CFRunLoopAddTimer(m_runLoop->m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes);
}
void DefaultGCActivityCallback::commonConstructor(Heap* heap, CFRunLoopRef runLoop)
{
d = adoptPtr(new DefaultGCActivityCallbackPlatformData);
memset(&d->context, 0, sizeof(CFRunLoopTimerContext));
d->context.info = heap;
d->runLoop = runLoop;
d->timer.adoptCF(CFRunLoopTimerCreate(0, decade, decade, 0, 0, DefaultGCActivityCallbackPlatformData::trigger, &d->context));
CFRunLoopAddTimer(d->runLoop.get(), d->timer.get(), kCFRunLoopCommonModes);
}
int main(int argc, char** argv) {
CFRunLoopTimerRef timer = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent()+1, 0,0,0, timeout, NULL);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopCommonModes);
am_device_notification* notification;
check("Subscribing to device notification",
AMDeviceNotificationSubscribe(&onDevice, 0,0,NULL, ¬ification));
CFRunLoopRun();
return 1;
}
HeapTimer::HeapTimer(VM* vm, CFRunLoopRef runLoop)
: m_vm(vm)
, m_runLoop(runLoop)
{
memset(&m_context, 0, sizeof(CFRunLoopTimerContext));
m_context.info = &vm->apiLock();
m_context.retain = retainAPILock;
m_context.release = releaseAPILock;
m_timer = adoptCF(CFRunLoopTimerCreate(0, s_decade, s_decade, 0, 0, HeapTimer::timerDidFire, &m_context));
CFRunLoopAddTimer(m_runLoop.get(), m_timer.get(), kCFRunLoopCommonModes);
}
// recveive - receive a packet
// Inputs:
// num = device to receive from (zero based)
// buf = buffer to receive packet
// len = buffer's size
// timeout = time to wait, in milliseconds
// Output:
// number of bytes received, or -1 on error
//
int pjrc_rawhid::receive(int num, void *buf, int len, int timeout)
{
hid_t *hid;
buffer_t *b;
CFRunLoopTimerRef timer=NULL;
CFRunLoopTimerContext context;
int ret=0, timeout_occurred=0;
if (len < 1) return 0;
hid = get_hid(num);
if (!hid || !hid->open) return -1;
if ((b = hid->first_buffer) != NULL) {
if (len > b->len) len = b->len;
memcpy(buf, b->buf, len);
hid->first_buffer = b->next;
free(b);
return len;
}
memset(&context, 0, sizeof(context));
context.info = &timeout_occurred;
timer = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() +
(double)timeout / 1000.0, 0, 0, 0, timeout_callback, &context);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopDefaultMode);
the_correct_runloop = CFRunLoopGetCurrent();
//qDebug("--");
while (1) {
//qDebug(".");
CFRunLoopRun(); // Found the problem: somehow the input_callback does not
// stop this CFRunLoopRun because it is hooked to a different run loop !!!
// Hence the use of the "correct_runloop" variable above.
//qDebug(" ..");
if ((b = hid->first_buffer) != NULL) {
if (len > b->len) len = b->len;
memcpy(buf, b->buf, len);
hid->first_buffer = b->next;
free(b);
ret = len;
//qDebug("*************");
break;
}
if (!hid->open) {
printf("pjrc_rawhid_recv, device not open\n");
ret = -1;
break;
}
if (timeout_occurred)
break;
}
CFRunLoopTimerInvalidate(timer);
CFRelease(timer);
return ret;
}
static void* Pt_Thread(void *p)
{
CFTimeInterval timerInterval;
CFRunLoopTimerContext timerContext;
CFRunLoopTimerRef timer;
PtThreadParams *params = (PtThreadParams*)p;
//CFTimeInterval timeout;
/* raise the thread's priority */
kern_return_t error;
thread_extended_policy_data_t extendedPolicy;
thread_precedence_policy_data_t precedencePolicy;
extendedPolicy.timeshare = 0;
error = thread_policy_set(mach_thread_self(), THREAD_EXTENDED_POLICY,
(thread_policy_t)&extendedPolicy,
THREAD_EXTENDED_POLICY_COUNT);
if (error != KERN_SUCCESS) {
mach_error("Couldn't set thread timeshare policy", error);
}
precedencePolicy.importance = THREAD_IMPORTANCE;
error = thread_policy_set(mach_thread_self(), THREAD_PRECEDENCE_POLICY,
(thread_policy_t)&precedencePolicy,
THREAD_PRECEDENCE_POLICY_COUNT);
if (error != KERN_SUCCESS) {
mach_error("Couldn't set thread precedence policy", error);
}
/* set up the timer context */
timerContext.version = 0;
timerContext.info = params;
timerContext.retain = NULL;
timerContext.release = NULL;
timerContext.copyDescription = NULL;
/* create a new timer */
timerInterval = (double)params->resolution / 1000.0;
timer = CFRunLoopTimerCreate(NULL, startTime+timerInterval, timerInterval,
0, 0, Pt_CFTimerCallback, &timerContext);
timerRunLoop = CFRunLoopGetCurrent();
CFRunLoopAddTimer(timerRunLoop, timer, CFSTR("PtTimeMode"));
/* run until we're told to stop by Pt_Stop() */
CFRunLoopRunInMode(CFSTR("PtTimeMode"), LONG_TIME, false);
CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), timer, CFSTR("PtTimeMode"));
CFRelease(timer);
free(params);
return NULL;
}
static void ParkEventLoop() {
// RunLoop needs at least one source, and 1e20 is pretty far into the future
CFRunLoopTimerRef t = CFRunLoopTimerCreate(kCFAllocatorDefault, 1.0e20, 0.0, 0, 0, dummyTimer, NULL);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), t, kCFRunLoopDefaultMode);
CFRelease(t);
// Park this thread in the main run loop.
int32_t result;
do {
result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e20, false);
} while (result != kCFRunLoopRunFinished);
}
void setSharedTimerFireTime(double fireTime)
{
ASSERT(sharedTimerFiredFunction);
if (sharedTimer) {
CFRunLoopTimerInvalidate(sharedTimer);
CFRelease(sharedTimer);
}
CFAbsoluteTime fireDate = fireTime - kCFAbsoluteTimeIntervalSince1970;
sharedTimer = CFRunLoopTimerCreate(0, fireDate, 0, 0, 0, timerFired, 0);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), sharedTimer, kCFRunLoopCommonModes);
}
static int run_loop_for_time(double duration)
{
bool timed_out = false;
CFRunLoopTimerContext timer_context = { 0, &timed_out, NULL, NULL, NULL };
CFRunLoopTimerRef timer = CFRunLoopTimerCreate(kCFAllocatorDefault, CFAbsoluteTimeGetCurrent() + duration, 0.0, 0, 0, timeout_cb, &timer_context);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopCommonModes);
CFRunLoopRun();
CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopCommonModes);
CFRelease(timer);
return timed_out ? -1 : 0;
}
void* os_inputmain(void* context){
usbdevice* kb = context;
int index = INDEX_OF(kb, keyboard);
// Schedule async events for the device on this thread
CFRunLoopRef runloop = CFRunLoopGetCurrent();
int count = (IS_RGB(kb->vendor, kb->product)) ? 4 : 3;
for(int i = 0; i < count; i++){
CFTypeRef eventsource;
kern_return_t res = (*kb->handles[i])->getAsyncEventSource(kb->handles[i], &eventsource);
if(res != kIOReturnSuccess){
ckb_err("Failed to start input thread for %s%d: %x\n", devpath, index, res);
return 0;
}
if(CFGetTypeID(eventsource) == CFRunLoopSourceGetTypeID())
CFRunLoopAddSource(runloop, (CFRunLoopSourceRef)eventsource, kCFRunLoopDefaultMode);
else if(CFGetTypeID(eventsource) == CFRunLoopTimerGetTypeID())
CFRunLoopAddTimer(runloop, (CFRunLoopTimerRef)eventsource, kCFRunLoopDefaultMode);
}
ckb_info("Starting input thread for %s%d\n", devpath, index);
// Start getting reports
uint8_t* urbinput[] = { malloc(8), malloc(32), malloc(MSG_SIZE) };
(*kb->handles[0])->setInputReportCallback(kb->handles[0], urbinput[0], 8, intreport, kb, 0);
if(IS_RGB(kb->vendor, kb->product)){
(*kb->handles[1])->setInputReportCallback(kb->handles[1], urbinput[1], 21, intreport, kb, 0);
(*kb->handles[2])->setInputReportCallback(kb->handles[2], urbinput[2], MSG_SIZE, intreport, kb, 0);
} else {
(*kb->handles[1])->setInputReportCallback(kb->handles[1], urbinput[1], 4, intreport, kb, 0);
(*kb->handles[2])->setInputReportCallback(kb->handles[2], urbinput[2], 15, intreport, kb, 0);
}
// Run the run loop for up to 2ms at a time, then check for key repeats
while(1){
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.002, false);
pthread_mutex_lock(imutex(kb));
if(!IS_CONNECTED(kb)){
// Make sure the device hasn't disconnected
pthread_mutex_unlock(imutex(kb));
break;
}
keyretrigger(kb);
pthread_mutex_unlock(imutex(kb));
}
// Clean up
ckb_info("Stopping input thread for %s%d\n", devpath, index);
free(urbinput[0]);
free(urbinput[1]);
free(urbinput[2]);
return 0;
}
void
osx_driver_setclipboard(
struct ts_display_t *display,
ts_clipboard_p clipboard)
{
//printf("%s called\n", __func__);
loop_display = display;
loop_clipboard = clipboard;
loop_to = NULL;
CFRunLoopTimerRef timer = CFRunLoopTimerCreate(NULL, 0, 0, 0, 0, osx_setclipboard_callback, NULL);
CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopCommonModes);
}
int rawhid_recv(int num, void *buf, int len, int timeout)
{
//fprintf(stderr,"rawhid_recv start len: %d\n",len);
//fprintf(stderr,"rawhid_recv start \n");
hid_t *hid;
buffer_t *b;
CFRunLoopTimerRef timer=NULL;
CFRunLoopTimerContext context;
int ret=0, timeout_occurred=0;
if (len < 1) return 0;
hid = get_hid(num);
if (!hid || !hid->open) return -1;
if ((b = hid->first_buffer) != NULL)
{
if (len > b->len) len = b->len;
memcpy(buf, b->buf, len);
hid->first_buffer = b->next;
free(b);
// fprintf(stderr,"rawhid_recv A len: %d\n\n",len);
return len;
}
memset(&context, 0, sizeof(context));
context.info = &timeout_occurred;
timer = CFRunLoopTimerCreate(NULL, CFAbsoluteTimeGetCurrent() +
(double)timeout / 1000.0, 0, 0, 0, timeout_callback, &context);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopDefaultMode);
while (1) {
CFRunLoopRun();
if ((b = hid->first_buffer) != NULL) {
if (len > b->len) len = b->len;
memcpy(buf, b->buf, len);
hid->first_buffer = b->next;
free(b);
ret = len;
break;
}
if (!hid->open) {
//printf("rawhid_recv, device not open\n");
ret = -1;
break;
}
if (timeout_occurred) break;
}
CFRunLoopTimerInvalidate(timer);
CFRelease(timer);
//fprintf(stderr,"rawhid_recv ret: %d\n",ret);
return ret;
}
static void
startComplete(pid_t pid, int status, struct rusage *rusage, void *context)
{
execCommand = 0;
if (WIFEXITED(status)) {
switch (WEXITSTATUS(status)) {
case AT_CMD_SUCCESS :
SCLog(TRUE, LOG_NOTICE, CFSTR("AppleTalk startup complete"));
if ((curState < 0) || (curState > (int)context)) {
// the stack is now up but we really want it down
stopAppleTalk(NULL, (void *)curState);
}
return;
case AT_CMD_ALREADY_RUNNING :
// the stack is already up but we're not sure
// if the configuration is correct, restart
SCLog(TRUE, LOG_NOTICE, CFSTR("AppleTalk already running, restarting"));
stopAppleTalk(NULL, (void *)curState);
return;
default :
break;
}
}
SCLog(TRUE, LOG_ERR,
CFSTR("AppleTalk startup failed, status = %d%s"),
WEXITSTATUS(status),
(execRetry > 1) ? " (retrying)" : "");
// startup failed, retry
if (--execRetry > 0) {
CFRunLoopTimerContext timerContext = { 0, (void *)curState, NULL, NULL, NULL };
CFRunLoopTimerRef timer;
timer = CFRunLoopTimerCreate(NULL,
CFAbsoluteTimeGetCurrent() + 1.0,
0.0,
0,
0,
startAppleTalk,
&timerContext);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopDefaultMode);
CFRelease(timer);
return;
}
return;
}
static void register_timeout(void)
{
if (idle_timer == NULL) {
idle_timer = CFRunLoopTimerCreate(kCFAllocatorDefault,
CFAbsoluteTimeGetCurrent() + TIMEOUT_IN_SECONDS,
TIMEOUT_IN_SECONDS, 0, 0, idle_timer_proc, NULL);
if (idle_timer == NULL) {
asl_log(NULL, NULL, ASL_LEVEL_CRIT,
"FATAL: failed to create idle timer, exiting.");
exit(1);
}
CFRunLoopAddTimer(CFRunLoopGetCurrent(), idle_timer,
kCFRunLoopDefaultMode);
}
}
CF_EXPORT void
rwsched_tasklet_CFRunLoopAddTimer(rwsched_tasklet_ptr_t sched_tasklet,
rwsched_CFRunLoopRef rl,
rwsched_CFRunLoopTimerRef rwsched_timer,
CFStringRef mode)
{
// Validate input paraemters
RW_CF_TYPE_VALIDATE(sched_tasklet, rwsched_tasklet_ptr_t);
rwsched_instance_ptr_t instance = sched_tasklet->instance;
RW_CF_TYPE_VALIDATE(instance, rwsched_instance_ptr_t);
RW_CF_TYPE_VALIDATE(rwsched_timer, rwsched_CFRunLoopTimerRef);
// Call the native CFRunLoop function
CFRunLoopAddTimer(rl, rwsched_timer->cf_object, mode);
}
int
main(int argc, const char * argv[])
{
int result = 0;
FSEventStreamRef streamRef;
Boolean startedOK;
int flush_seconds = 3600; // When to force-flush any queued events
if(argc < 2 || strcasecmp(argv[1], "--help") == 0) {
fprintf(stderr, "usage: %s path ...\n", argv[0]);
exit(1);
}
const char **paths = &argv[1];
streamRef = my_FSEventStreamCreate(paths, argc-1);
FSEventStreamScheduleWithRunLoop(streamRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
startedOK = FSEventStreamStart(streamRef);
if (!startedOK) {
log_error("FSEventStreamStart(streamRef) failed");
goto out;
}
if (flush_seconds >= 0) {
log_debug("CFAbsoluteTimeGetCurrent() => %.3f", CFAbsoluteTimeGetCurrent());
CFAllocatorRef allocator = kCFAllocatorDefault;
CFAbsoluteTime fireDate = CFAbsoluteTimeGetCurrent() + /*settings->*/flush_seconds;
CFTimeInterval interval = /*settings->*/flush_seconds;
CFOptionFlags flags = 0;
CFIndex order = 0;
CFRunLoopTimerCallBack callback = (CFRunLoopTimerCallBack)timer_callback;
CFRunLoopTimerContext context = { 0, streamRef, NULL, NULL, NULL };
CFRunLoopTimerRef timer = CFRunLoopTimerCreate(allocator, fireDate, interval, flags, order, callback, &context);
CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopDefaultMode);
}
// Run
CFRunLoopRun();
// Stop / Invalidate / Release
FSEventStreamStop(streamRef);
out:
FSEventStreamInvalidate(streamRef);
FSEventStreamRelease(streamRef);
return result;
}
