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);
}
