void flipThread(void *refcon) { KplScreen screen = refcon; FskThread mainThread = FskThreadGetMain(); FskTimeRecord later; SInt32 ms; FskThreadInitializationComplete(FskThreadGetCurrent()); while (!gQuitting) { //Save the last Flip time FskTimeGetNow(&gKplScreen->lastFlipTime); FskTimeCopy(&later, &gKplScreen->nextFlipTime); FskTimeSub(&gKplScreen->lastFlipTime, &later); ms = FskTimeInMS(&later); if (ms > 0) { FskDelay(ms); MLOG("[%s] delay %d ms\n", threadName, ms); } // Kick off the next cycle if (gKplScreen->drawingPumpEnabled) { FskSemaphoreAcquire(screen->flipSemaphore); gKplScreen->callbackPostedCount++; FskThreadPostCallback(mainThread, drawingPumpCallback, (void*)gKplScreen->callbackPostedCount, NULL, NULL, NULL); } } }
// --------------------------------------------------------------------- void sNotifyInterfaceNotifiers(FskNetInterfaceRecord *iface, UInt32 status) { FskNetInterfaceNotifier callback = NULL, next; FskThread thread = FskThreadGetCurrent(); callback = (FskNetInterfaceNotifier)FskListMutexGetNext(interfaceChangeCBList, NULL); while (callback) { next = (FskNetInterfaceNotifier)FskListMutexGetNext(interfaceChangeCBList, callback); #if 0 && SUPPORT_INSTRUMENTATION if (FskInstrumentedItemHasListeners(callback)) { FskNetInterfaceRecord *iface = (FskNetInterfaceRecord *)FskNetInterfaceFindByName(ifcName); FskInterfaceInstrData data; data.notf = callback; data.ifc = iface; data.status = status; FskInstrumentedItemSendMessage(callback, kFskNetInstrMsgInterfaceNotify, &data); } #endif /* SUPPORT_INSTRUMENTATION */ if (callback->thread != thread) { FskNetInterfaceRecord *interFace; if (kFskErrNone == FskMemPtrNewFromData(sizeof(FskNetInterfaceRecord), iface, &interFace)) { interFace->next = NULL; interFace->name = FskStrDoCopy(iface->name); // POST notify FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, " - posting callback to thread %s for interface %s", callback->thread->name, iface->name); FskThreadPostCallback(callback->thread, doNetIfcCallback, (void*)callback->callback, (void*)interFace, (void*)status, (void*)callback->param); } } else { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "callback->thread %s - call", callback->thread->name); (callback->callback)(iface, status, callback->param); } callback = next; } }
static FskErr newSSLVM(FskECMAScript *vmp) { FskECMAScript vm; FskErr err; #ifdef KPR_CONFIG if ((err = FskMemPtrNewClear(sizeof(FskECMAScriptRecord), &vm)) != kFskErrNone) return err; if ((vm->the = xsAliasMachine(&anAllocation, gShell->root, "SSL", vm)) == NULL) { FskMemPtrDispose(vm); return kFskErrMemFull; } #else if (gSSLVM == NULL) return kFskErrUnimplemented; if ((err = FskMemPtrNewFromData(sizeof(FskECMAScriptRecord), gSSLVM, &vm)) != kFskErrNone) return err; vm->the = NULL; vm->context = NULL; vm->refcon = NULL; vm->libraries = NULL; vm->name = FskStrDoCopy("SSL"); vm->thread = FskThreadGetCurrent(); vm->id = (UInt32)vm; if ((vm->the = xsAliasMachine(&anAllocation, gSSLVM->the, vm->name, vm)) == NULL) { FskMemPtrDispose(vm); return kFskErrMemFull; } #endif *vmp = vm; return err; }
static FskErr FskGPIONew(FskGPIO *gpioOut, int pin, char *pinName, GPIOdirection direction) { FskErr err = kFskErrNone; FskGPIO gpio = NULL; err = FskMemPtrNewClear(sizeof(FskGPIORecord), (FskMemPtr *)&gpio); BAIL_IF_ERR(err); gpio->pinNum = pin; gpio->realPin = FskHardwarePinsMux(pin, kFskHardwarePinGPIO); gpio->thread = FskThreadGetCurrent(); if (gpio->realPin < 0) BAIL(kFskErrInvalidParameter); err = FskGPIOPlatformInit(gpio); BAIL_IF_ERR(err); if (undefined != direction) { err = FskGPIOPlatformSetDirection(gpio, direction); BAIL_IF_ERR(err); } bail: if (err && gpio) { FskGPIOPlatformDispose(gpio); FskMemPtrDisposeAt(&gpio); } *gpioOut = gpio; return err; }
FskErr FskFSVolumeNotifierNew(FskVolumeNotifierCallbackProc callback, void *refCon, FskFSVolumeNotifier *volNtfOut) { FskErr err; FskFSVolumeNotifier volNtf = NULL; FskAndroidFilesPrintfDebug("VolumeNotifierNew\n"); if (NULL == gVolNotifiers) { err = FskMutexNew(&gVolNotifiersMutex, "volume notifier"); BAIL_IF_ERR(err); } err = FskMemPtrNewClear(sizeof(FskFSVolumeNotifierRecord), (FskMemPtr*)(void*)&volNtf); BAIL_IF_ERR(err); FskMutexAcquire(gVolNotifiersMutex); volNtf->dispatch.dispatch = &gFSDispatch; volNtf->dispatch.refcon = NULL; volNtf->callback = callback; volNtf->refCon = refCon; volNtf->callbackThread = FskThreadGetCurrent(); FskListPrepend(&gVolNotifiers, &volNtf->next); FskMutexRelease(gVolNotifiersMutex); bail: *volNtfOut = volNtf; return err; }
char *FskEnvironmentGet(char *name) { FskThread thread = FskThreadGetCurrent(); if (thread->environmentVariables) { char *result = FskAssociativeArrayElementGetString(thread->environmentVariables, name); if (result) return result; } return FskAssociativeArrayElementGetString(gEnvironment, name); }
static void sFskHandleNetworkInterfacesChanged() { #if SUPPORT_INSTRUMENTATION FskThread thread = FskThreadGetCurrent(); FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "Interfaces changed -- thread is: %x - %s", thread, thread->name); #endif /* SUPPORT_INSTRUMENTATION */ if (sHaveNetworkInterfacesChanged()) { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "Interfaces have changed - about to call notify"); sNotifyNetworkInterfacesChanged(); FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "Interfaces have changed - after calling notify"); } }
void FskEnvironmentSet(const char *name, const char *value) { FskThread thread = FskThreadGetCurrent(); FskAssociativeArray vars = gEnvironment; if (!(kFskThreadFlagsIsMain & thread->flags)) { if (NULL == thread->environmentVariables) thread->environmentVariables = FskAssociativeArrayNew(); vars = thread->environmentVariables; } FskAssociativeArrayElementSetString(vars, name, (char *)value); }
/* interface is optional. If NULL, then all interfaces will be used */ FskErr FskHTTPServerCreate(int port, char *interfaceName, FskHTTPServer *server, void *refCon, Boolean ssl) { FskHTTPServer http; FskErr err; FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerCreate\n"); err = FskMemPtrNewClear(sizeof(FskHTTPServerRecord), (FskMemPtr*)&http); BAIL_IF_ERR(err); sFskHTTPServerUpUse(http); http->stopped = true; http->refCon = refCon; http->port = port; http->keepAliveTimeout = kFskHTTPKeepAliveTimeout; http->defaultBufferSize = kFskHTTPServerDefaultBufferSize; http->owner = FskThreadGetCurrent(); http->ssl = ssl; snprintf(http->name, 64, "%s:%d", interfaceName ? interfaceName : "all", port); FskInstrumentedItemNew(http, http->name, &gFskHTTPServerTypeInstrumentation); if (interfaceName) { err = FskHTTPServerListenerAdd(http, port, interfaceName, NULL); } else { FskNetInterfaceRecord *ifc; int i, numI; http->all = true; numI = FskNetInterfaceEnumerate(); for (i=0; i<numI; i++) { FskErr notErr = FskNetInterfaceDescribe(i, &ifc); if (notErr) continue; if (ifc->status) { notErr = FskHTTPServerListenerAdd(http, port, ifc->name, NULL); if (notErr) err = notErr; } FskNetInterfaceDescriptionDispose(ifc); } } http->interfaceNotifier = FskNetInterfaceAddNotifier(httpServerInterfaceChanged, http, "http server"); bail: *server = http; return err; }
FskErr KprWebSocketServerNew(KprWebSocketServer* it, void *refCon) { FskErr err = kFskErrNone; KprWebSocketServer self = NULL; bailIfError(FskMemPtrNewClear(sizeof(KprWebSocketServerRecord), it)); self = *it; self->stopped = false; self->refCon = refCon; self->owner = FskThreadGetCurrent(); // self->interfaceNotifier = FskNetInterfaceAddNotifier(KprWebSocketServerInterfaceChanged, self, "websocket server"); return err; bail: KprWebSocketServerDispose(self); return err; }
void KprMessageComplete(KprMessage self) { char* url; FskThread thread = KprShellGetThread(gShell); if (!thread) return; // @@ happens on exit if (thread != FskThreadGetCurrent()) { FskThreadPostCallback(thread, (FskThreadCallback)KprMessageComplete, self, NULL, NULL, NULL); return; } FskInstrumentedItemSendMessageDebug(self, kprInstrumentedMessageComplete, self); if (FskListRemove(&gShell->messages, self)) { self->usage--; // message queue self->waiting = false; url = KprMessageGetResponseHeader(self, "location"); if (url && (!FskStrCompareWithLength(self->url, "xkpr", 4)) && ((!self->sniffing) || (!FskStrCompareWithLength(url, "xkpr", 4)))) { FskMemPtrDispose(self->url); self->url = FskStrDoCopy(url); //bailIfNULL(self->url); KprURLSplit(self->url, &self->parts); FskAssociativeArrayDispose(self->response.headers); self->response.headers = NULL; FskMemPtrDispose(self->response.body); self->response.body = NULL; self->response.size = 0; if (self->request.target) self->usage--; // @@ request if (kFskErrNone == KprMessageInvoke(self, self->request.callback, self->request.dispose, self->request.target)) return; } if (self->request.target) { if (self->request.callback) (*self->request.callback)(self, self->request.target); if (self->request.dispose) (*self->request.dispose)(self->request.target); self->request.callback = NULL; self->request.dispose = NULL; self->request.target = NULL; self->usage--; // request } if (!self->usage) KprMessageDispose(self); } }
static void KprServicesLoop(void* theParameter) { xsAllocation allocation = { 1100000, // 700 * 1024, 32 * 1024, 70000, // 62000, 4096, 2048, 16000, 1993 }; FskErr err = kFskErrNone; KprService service = gServices; FskThread thread = FskThreadGetCurrent(); gServiceMachine = xsAliasMachine(&allocation, gShell->root, "services", gShell); bailIfNULL(gServiceMachine); while (service) { if (service->flags & kprServicesThread) { FskInstrumentedTypePrintfNormal(&KprServiceInstrumentation, "Starting %s", service->id); (*service->start)(service, thread, gServiceMachine); } service = service->next; } FskThreadInitializationComplete(thread); while (!gServicesThreadQuitting) FskThreadRunloopCycle(-1); service = gServices; while (service) { if (service->flags & kprServicesThread) { FskInstrumentedTypePrintfNormal(&KprServiceInstrumentation, "Stopping %s", service->id); (*service->stop)(service); } service = service->next; } bail: if (gServiceMachine) { xsDeleteMachine(gServiceMachine); gServiceMachine = NULL; } return; }
static void gpioPoller(FskTimeCallBack callback, const FskTime time, void *param) { FskGPIO walker; FskThread thread = FskThreadGetCurrent(); for (walker = gGPIOPollers; NULL != walker; walker = walker->next) { int value = FskGPIOPlatformRead(walker); if (value == walker->pollerValue) continue; walker->pollerValue = value; if (thread == walker->thread) KprPinsPollerRun(walker->poller); else FskThreadPostCallback(walker->thread, gpioPollerThreadCallback, walker, NULL, NULL, NULL); } FskTimeCallbackScheduleFuture(gGPIOPoller, 0, 33, gpioPoller, NULL); }
FskNetInterfaceNotifier FskNetInterfaceAddNotifier(FskNetInterfaceChangedCallback callback, void *param, char *debugName) { FskNetInterfaceNotifier notRef = NULL; FskThread thread = FskThreadGetCurrent(); UInt32 nameLen = debugName ? FskStrLen(debugName) + 1 : 0; if (kFskErrNone == FskMemPtrNewClear(sizeof(FskNetInterfaceNotifierRec) + nameLen, ¬Ref)) { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NetInterfaceNotifier NEW -- %x", notRef); notRef->callback = callback; notRef->param = param; notRef->thread = thread; if (nameLen) FskMemMove(notRef->name, debugName, nameLen); FskListMutexPrepend(interfaceChangeCBList, notRef); FskInstrumentedItemNew(notRef, notRef->name, &gNetInterfaceNotifierTypeInstrumentation); } return notRef; }
void flushNowCallback(FskTimeCallBack callback, const FskTime time, void *param) { FskAudioOut audioOut = (FskAudioOut)param; androidAudioExt *ext = (androidAudioExt*)audioOut->ext; Boolean isValid = false; FskAudioNativePrintfDebug("flushNowCallback"); androidAudioOutIsValid(audioOut, &isValid); if (!isValid || audioOut->thread == NULL) { FskAudioNativePrintfVerbose("flushNowCallback - isValid? (%s) - audioOut->thread (%x) - bail", isValid ? "yes" : "no", audioOut->thread); return; } // removeFromQueue(audioOut, kUsed); if (FskThreadGetCurrent() == audioOut->thread) flushAndRefill(audioOut, NULL, NULL, NULL); else FskThreadPostCallback(audioOut->thread, flushAndRefill, audioOut, NULL, NULL, NULL); if (audioOut->playing) FskTimeCallbackScheduleFuture(ext->flushTimer, 0, kFlushAndRefillTime, flushNowCallback, audioOut); }
////////////// Main and Init ///////////////// static void FskGtkWindowLoop(void *refcon) { FskWindow fskWindow = (FskWindow)refcon; FskGtkWindow gtkWin = (FskGtkWindow)fskWindow->gtkWin; GtkWidget *win; GdkPixbuf *iconBuf; // Start GTK special initialization XInitThreads(); //fix a xcb issue happened when using multithread gtk, see http://stackoverflow.com/a/18690540/472927 gtk_init(NULL, NULL); gtkWin->owner = fskWindow; gtkWin->window = win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(win, 750, 505); // Set App Icon char *iconPath = FskStrDoCat(FskGetApplicationPath(), "fsk.png"); iconBuf = gdk_pixbuf_new_from_file(iconPath, NULL); if(iconBuf != NULL) { gtk_window_set_icon(GTK_WINDOW(win), iconBuf); g_object_unref(G_OBJECT(iconBuf)); } FskMemPtrDispose(iconPath); gtkWin->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(win), gtkWin->vbox); gtk_widget_show(gtkWin->vbox); gtkWin->menubar = gtk_menu_bar_new(); gtk_widget_show(gtkWin->menubar); gtkWin->da = gtk_drawing_area_new(); gtk_widget_show(gtkWin->da); gtkWin->accelGroup = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(win), gtkWin->accelGroup); FskMutexNew(>kWin->bufMutex, "drawAreaBuffer"); gtkWin->queue = g_async_queue_new(); gtk_widget_add_events(GTK_WIDGET(win), GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK); gtk_widget_add_events(GTK_WIDGET(gtkWin->da), GDK_ALL_EVENTS_MASK); g_signal_connect(win, "destroy", G_CALLBACK(app_quit), gtkWin); g_signal_connect(win, "key-press-event", G_CALLBACK(on_key_press), gtkWin); g_signal_connect(win, "key-release-event", G_CALLBACK(on_key_release), gtkWin); g_signal_connect(win, "configure-event", G_CALLBACK(configure_event_win), gtkWin); // If want to resize draw-area, it will be the event receiver. g_signal_connect(gtkWin->da, "configure-event", G_CALLBACK(configure_event_cb), gtkWin); g_signal_connect(gtkWin->da, "draw", G_CALLBACK(draw_callback), gtkWin); g_signal_connect(gtkWin->da, "button-press-event", G_CALLBACK(on_button_press), gtkWin); g_signal_connect(gtkWin->da, "button-release-event",G_CALLBACK(on_button_release), gtkWin); g_signal_connect(gtkWin->da, "motion-notify-event", G_CALLBACK(motion_notify), gtkWin); gtk_box_pack_start(GTK_BOX(gtkWin->vbox), gtkWin->menubar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(gtkWin->vbox), gtkWin->da, TRUE, TRUE, 0); // Set all to true! gdk_threads_add_idle(idle_func, gtkWin); //gtk_widget_show_all(win); FskThreadInitializationComplete(FskThreadGetCurrent()); gtk_main(); }
void fxQueuePromiseJobs(txMachine* the) { FskThread thread = FskThreadGetCurrent(); FskThreadPostCallback(thread, (FskThreadCallback)fxPerformPromiseJobs, the, NULL, NULL, NULL); }
FskErr androidAudioOutNew(FskAudioOut *audioOutOut, UInt32 outputID, UInt32 format) { SLresult res; FskErr err = kFskErrNone; FskAudioOut audioOut = NULL; androidAudioExt *ext = NULL; int i; SLDataLocator_OutputMix loc_outmix; SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2}; SLDataFormat_PCM pcm; SLDataSink audioSnk; SLDataSource audioSrc = {&loc_bufq, &pcm}; if (NULL == audioOuts) { err = FskListMutexNew(&audioOuts, "audioOuts"); if (err) goto bail; } err = FskMemPtrNewClear(sizeof(FskAudioOutRecord), (FskMemPtr*)&audioOut); if (err) goto bail; err = FskMemPtrNewClear(sizeof(androidAudioExt), (FskMemPtr*)&ext); if (err) goto bail; err = FskMemPtrNewClear(AUDIO_DATA_BUFFER_SIZE, (FskMemPtr*)&ext->audioBuf[0]); if (err) goto bail; err = FskMemPtrNewClear(AUDIO_DATA_BUFFER_SIZE, (FskMemPtr*)&ext->audioBuf[1]); if (err) goto bail; ext->nextBuf = 0; ext->audioFilled[0] = 0; ext->audioFilled[1] = 0; audioOut->ext = ext; ext->parent = audioOut; audioOut->thread = FskThreadGetCurrent(); audioOut->format = kFskAudioFormatPCM16BitLittleEndian; audioOut->sampleRate = 44100; audioOut->numChannels = 2; ext->sampleSize = audioOut->numChannels * 2; if (sBufferedSamplesTarget > 0 && sBufferedSamplesTarget < 20) { audioOut->bufferedSamplesTarget = sBufferedSamplesTarget * audioOut->sampleRate * ext->sampleSize; } else audioOut->bufferedSamplesTarget = audioOut->sampleRate * ext->sampleSize; // 1 second default SLboolean required[MAX_NUMBER_INTERFACES]; SLInterfaceID iidArray[MAX_NUMBER_INTERFACES]; pcm.formatType = SL_DATAFORMAT_PCM; pcm.numChannels = audioOut->numChannels; pcm.samplesPerSec = audioOut->sampleRate * 1000; pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16; pcm.containerSize = 16; pcm.channelMask = audioOut->numChannels == 1 ? SL_SPEAKER_FRONT_CENTER : (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT); pcm.endianness = SL_BYTEORDER_LITTLEENDIAN; for (i=0; i<MAX_NUMBER_INTERFACES; i++) { required[i] = SL_BOOLEAN_FALSE; iidArray[i] = SL_IID_NULL; } res = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, (void*)&ext->EngineItf); CheckErr("GetInterface", res); res = (*ext->EngineItf)->CreateOutputMix(ext->EngineItf, &ext->outputMixObject, 0, NULL, NULL); CheckErr("CreateOutputMix", res); res = (*ext->outputMixObject)->Realize(ext->outputMixObject, SL_BOOLEAN_FALSE); CheckErr("Realize OutputMix", res); loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX; loc_outmix.outputMix = ext->outputMixObject; audioSnk.pLocator = &loc_outmix; audioSnk.pFormat = NULL; iidArray[0] = SL_IID_BUFFERQUEUE; required[0] = SL_BOOLEAN_TRUE; res = (*ext->EngineItf)->CreateAudioPlayer(ext->EngineItf, &ext->player, &audioSrc, &audioSnk, 1, iidArray, required); CheckErr("CreateAudioPlayer", res); res = (*ext->player)->Realize(ext->player, SL_BOOLEAN_FALSE); CheckErr(" player->Realize", res); res = (*ext->player)->GetInterface(ext->player, SL_IID_PLAY, (void*)&ext->playItf); CheckErr(" ext->player->GetInterface Play", res); res = (*ext->player)->GetInterface(ext->player, SL_IID_BUFFERQUEUE, (void*)&ext->bufferQueueItf); CheckErr(" player->GetInterface BufferQueue", res); res = (*ext->bufferQueueItf)->RegisterCallback(ext->bufferQueueItf, BufferQueueCallback, ext); CheckErr(" bufferQueueItf->RegisterCallback BufferQueue", res); // res = (*ext->volumeItf)->SetVolumeLevel(ext->volumeItf, -300); // CheckErr(" volumeItf->SetVolumeLevel", res); // if (gAudio) // FskAudioNativePrintfDebug("- about to trash existing gAudio %x", gAudio); FskListMutexNew(&audioOut->blocks, "audio blocks"); FskMutexNew(&ext->getSamplePositionMutex, "audio getSamplePosition"); FskListMutexAppend(audioOuts, audioOut); bail: if (err) { androidAudioOutDispose(audioOut); audioOut = NULL; } *audioOutOut = audioOut; return err; }
// --------------------------------------------------------------------- static Boolean sNotifyNetworkInterfacesChanged() { FskErr err; Boolean retVal = false; FskNetInterfaceRecord *existing, *newer, *check, *old; #if SUPPORT_INSTRUMENTATION FskThread thread = FskThreadGetCurrent(); FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- thread is: %x - %s", thread, thread->name); #endif /* SUPPORT_INSTRUMENTATION */ // If we fail to enumerate interfaces, assume there are no interfaces available now and // notify our clients that their interfaces have been removed. err = sFskNetInterfaceEnumerate(&newer); if (err) { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- can't enumerate, Down the interfaces"); FskMutexAcquire(gNetworkInterfaceList->mutex); existing = (FskNetInterfaceRecord *)gNetworkInterfaceList->list; while (existing) { sNotifyInterfaceNotifiers(existing, kFskNetInterfaceStatusRemoved); existing = existing->next; } sDisposeInterfaceList((FskNetInterfaceRecord**)(void*)&gNetworkInterfaceList->list); FskMutexRelease(gNetworkInterfaceList->mutex); return true; } FskMutexAcquire(gNetworkInterfaceList->mutex); old = (FskNetInterfaceRecord *)gNetworkInterfaceList->list; existing = (FskNetInterfaceRecord *)gNetworkInterfaceList->list; gNetworkInterfaceList->list = newer; while (existing) { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- looking for %s in the newer list", existing->name); check = sFskNetInterfaceFindByName(existing->name, newer); if (check) { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- found %s in the newer list", existing->name); if (sCompareInterfaces(check, existing) != 0) { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- %s changed - NOTIFY", existing->name); sNotifyInterfaceNotifiers(check, kFskNetInterfaceStatusChanged); } else { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- %s didn't change - no notify", existing->name); } } else { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- not found %s in the newer list - remove it.", existing->name); sNotifyInterfaceNotifiers(existing, kFskNetInterfaceStatusRemoved); } existing = existing->next; } existing = newer; while (existing) { check = sFskNetInterfaceFindByName(existing->name, old); if (!check) { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- new interface %s not in the older list - ADD it.", existing->name); sNotifyInterfaceNotifiers(existing, kFskNetInterfaceStatusNew); } existing = existing->next; } FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NotifyNetworkInterfacesChanged -- toss old list."); sDisposeInterfaceList(&old); existing = gNetworkInterfaceList->list; while (existing) { FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, " -- %s - %08x %08x %d", existing->name, existing->ip, existing->netmask, existing->status); existing = existing->next; } FskMutexRelease(gNetworkInterfaceList->mutex); return retVal; }
Boolean FskSSLCheckServerCert(SSL *ssl, char *hostname) { long err; X509 *peer; char peer_CN[256]; err = SSL_get_verify_result(ssl); #if 0 if ((err != X509_V_OK) && (err != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) && (err != X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY)) { ERR_print_errors_fp(stderr); fprintf(stderr, "[%s] cert for %s didn't verify %d %s\n", threadTag(FskThreadGetCurrent()), hostname, err, X509_verify_cert_error_string(err)); #else if (err != X509_V_OK) { if ((NULL != FskStrStr(hostname, "google.com")) || (NULL != FskStrStr(hostname, "googleapis.com")) || (NULL != FskStrStr(hostname, "twitter.com")) || (NULL != FskStrStr(hostname, "yammer.com")) || (NULL != FskStrStr(hostname, "facebook.com")) || (NULL != FskStrStr(hostname, "foursquare.com")) || (NULL != FskStrStr(hostname, "akamaihd.net")) || (NULL != FskStrStr(hostname, "fbcdn.net")) || (NULL != FskStrStr(hostname, "radiotime.com")) || (NULL != FskStrStr(hostname, "s3.amazonaws.com")) || (NULL != FskStrStr(hostname, "orb.com"))) { if ((err != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) && (err != X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY)) { return false; } myprintf((stderr, "b) cert didn't verify because %d %s\n", err, X509_verify_cert_error_string(err))); myprintf((stderr, " but since it's %s we'll let it through\n", hostname)); } else { #endif return false; } } peer = SSL_get_peer_certificate(ssl); X509_NAME_get_text_by_NID(X509_get_subject_name(peer), NID_commonName, peer_CN, 256); //fprintf(stderr, "comparing peer_CN %s with hostname %s\n", peer_CN, hostname); if (FskStrCompareCaseInsensitive(peer_CN, hostname)) { int pos, L, subL; char *match = peer_CN + 1; subL = FskStrLen(match); L = FskStrLen(hostname); if (peer_CN[0] == '*') { pos = L - subL; if (0 == FskStrCompareCaseInsensitive(match, hostname + pos)) { //fprintf(stderr, "Matched wildcard %s and %s\n", match, hostname + pos); return true; } } if ( (FskStrEndsWith(match, "akamaihd.net") && FskStrEndsWith(hostname, "akamai.net")) || (FskStrEndsWith(match, "akamai.net") && FskStrEndsWith(hostname, "akamaihd.net")) ) { return true; } myprintf((stderr, "cert common name %s and host %s don't match\n", peer_CN, hostname)); return false; } return true; } //SSL_CTX *FskSSLInitialize(char *keyfile, char *password) static SSL_CTX *FskOpenSSLInitialize(const char *calistpath) { SSL_METHOD *method; SSL_CTX *context; if (gSSLContext) { return gSSLContext; } else { SSL_library_init(); SSL_load_error_strings(); // not necessary, but useful } method = SSLv23_method(); context = SSL_CTX_new(method); #if 0 if (FskStrLen(keyfile) > 0) { keyfile = FskEnvironmentDoApply(FskStrDoCopy(keyfile)); if (!SSL_CTX_use_certificate_chain_file(context, keyfile)) doSSLError("Can't read certificate file"); fprintf(stderr, "keyfile is %s\n", keyfile); if (FskStrLen(password) > 0) { gSSLPassword = FskStrDoCopy(password); SSL_CTX_set_default_passwd_cb(context, passwordCallback); if (!SSL_CTX_use_PrivateKey_file(context, keyfile, SSL_FILETYPE_PEM)) doSSLError( "Can't read private keyfile"); } FskMemPtrDispose(keyfile); } #endif #if TARGET_OS_WIN32 { // try to make the path 8.3 safe to avoid nightmares with multibyte character paths, etc. UInt16 *nativePath; if (kFskErrNone == FskFilePathToNative(calistpath, (char **)&nativePath)) { DWORD shortLen; shortLen = GetShortPathNameW(nativePath, NULL, 0); if (0 != shortLen) { UInt16 *eightDotThree; if (kFskErrNone == FskMemPtrNewClear(shortLen * 2, (FskMemPtr *)&eightDotThree)) { if (0 != GetShortPathNameW(nativePath, eightDotThree, shortLen)) { char *utf8; UInt32 utf8Len; if (kFskErrNone == FskTextUnicode16LEToUTF8(eightDotThree, shortLen * 2, &utf8, &utf8Len)) { char *enc; if (kFskErrNone == FskTextToPlatform(utf8, utf8Len, &enc, NULL)) { FskMemPtrDispose(calistpath); calistpath = enc; } FskMemPtrDispose(utf8); } } FskMemPtrDispose(eightDotThree); } } FskMemPtrDispose(nativePath); } } #endif if (!(SSL_CTX_load_verify_locations(context, calistpath, 0))) { doSSLError("Can't read default CA list"); } SSL_CTX_set_verify_depth(context, 0); // SSL_CTX_set_verify(context, SSL_VERIFY_PEER, 0); gSSLContext = context; return context; }
static Boolean doFormatMessageHTTPServer(FskInstrumentedType dispatch, UInt32 msg, void *msgData, char *buffer, UInt32 bufferSize) { FskHTTPServerListener listener = (FskHTTPServerListener)msgData; FskHTTPServerRequest request = (FskHTTPServerRequest)msgData; FskHTTPServer http = (FskHTTPServer)msgData; FskHTTPInstrMsgDataRecord *data = (FskHTTPInstrMsgDataRecord*)msgData; FskThread thread; char tmp[64]; UInt32 s; const UInt32 kMessageTextSize = 512; switch (msg) { case kFskHTTPInstrMsgRequestState: thread = FskThreadGetCurrent(); if (request->http->owner != thread) snprintf(buffer, bufferSize, "RUNNING IN (%p:%s) SHOULD BE (%p:%s) %s - %s", thread, thread->name, request->http->owner, request->http->owner->name, request->http->name, httpserverstate2str(request->state)); else snprintf(buffer, bufferSize, "%s - %s", request->http->name, httpserverstate2str(request->state)); return true; case kFskHTTPInstrMsgErrString: snprintf(buffer, bufferSize, "%s", (char*)msgData); return true; case kFskHTTPInstrMsgNowListening: snprintf(buffer, bufferSize, "listening to %s:%d", listener->ifcName, listener->port); return true; case kFskHTTPInstrMsgFailedListener: snprintf(buffer, bufferSize, "no longer listening to %s", listener->http->name); return true; case kFskHTTPInstrMsgConnectionRefusedStopped: snprintf(buffer, bufferSize, "refused connection - server stopped %s", listener->http->name); return true; case kFskHTTPInstrMsgServerStart: snprintf(buffer, bufferSize, "%s starting", http->name); return true; case kFskHTTPInstrMsgServerStartedAlready: snprintf(buffer, bufferSize, "%s already started", http->name); return true; case kFskHTTPInstrMsgServerStop: snprintf(buffer, bufferSize, "%s stopping", http->name); return true; case kFskHTTPInstrMsgServerStoppedAlready: snprintf(buffer, bufferSize, "%s already stopped", http->name); return true; case kFskHTTPInstrMsgRequestKillIdle: FskNetIPandPortToString(request->requesterAddress, request->requesterPort, tmp); snprintf(buffer, bufferSize, "%s - killing idle request connection from %s", request->http->name, tmp); return true; case kFskHTTPInstrMsgRequestRemainsOnClose: FskNetIPandPortToString(request->requesterAddress, request->requesterPort, tmp); snprintf(buffer, bufferSize, "closing %s - killing request from %s", request->http->name, tmp); return true; case kFskHTTPInstrMsgRequestRecvData: case kFskHTTPInstrMsgRequestSendData: s = data->amt -1; if ((s + kMessageTextSize) > bufferSize) s = bufferSize - kMessageTextSize; tmp[0] = data->buffer[s]; data->buffer[s] = '\0'; if (msg == kFskHTTPInstrMsgRequestSendData) snprintf(buffer, bufferSize, "send data (%u bytes): %s%c", (unsigned)data->amt, data->buffer, tmp[0]); else snprintf(buffer, bufferSize, "recv data (%u bytes): %s%c", (unsigned)data->amt, data->buffer, tmp[0]); data->buffer[s] = tmp[0]; return true; default: return false; } return false; }
void KprZeroconfBrowserServiceDown(KprZeroconfBrowser self, KprZeroconfServiceInfo service) { if (!self) self = KprZeroconfBrowserFind(NULL, service->type); if (!self) return; FskInstrumentedItemPrintfDebug(self, "%p - KprZeroconfBrowserServiceDown %s %s - %p %p", self, service->type, service->name, KprShellGetThread(gShell), FskThreadGetCurrent()); if (self->serviceDownCallback) (*self->serviceDownCallback)(self, service); KprZeroconfServiceInfoDispose(service); }