FskErr KprZeroconfServiceInfoNew(KprZeroconfServiceInfo *it, const char* type, const char* name, const char* host, const char* ip, UInt32 port, const UInt32 interfaceIndex, char* txt)
{
FskErr err = kFskErrNone;
KprZeroconfServiceInfo self = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KprZeroconfServiceInfoRecord), it));
self = *it;
self->type = FskStrDoCopy(type);
bailIfNULL(self->type);
self->name = FskStrDoCopy(name);
bailIfNULL(self->name);
if (host) {
self->host = FskStrDoCopy(host);
bailIfNULL(self->host);
}
if (ip) {
self->ip = FskStrDoCopy(ip);
bailIfNULL(self->ip);
}
self->port = port;
self->interfaceIndex = interfaceIndex;
if (txt) {
self->txt = FskStrDoCopy(txt);
bailIfNULL(self->txt);
}
FskInstrumentedItemNew(self, NULL, &KprZeroconfServiceInfoInstrumentation);
bail:
if (err)
KprZeroconfServiceInfoDispose(self);
return err;
}
FskErr KprDebugMachineNew(KprDebugMachine* it, KprDebug debug, FskSocket skt)
{
FskErr err = kFskErrNone;
KprDebugMachine self = NULL;
UInt32 ip;
int port;
BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KprDebugMachineRecord), it));
self = *it;
self->debug = debug;
self->socket = skt;
BAIL_IF_ERR(err = FskNetSocketGetRemoteAddress(skt, &ip, &port));
FskNetIPandPortToString(ip, port, self->address);
FskListAppend(&self->debug->machine, self);
FskNetSocketReceiveBufferSetSize(self->socket, kSocketBufferSize);
FskThreadAddDataHandler(&self->reader, (FskThreadDataSource)self->socket, KprDebugMachineDataReader, true, false, self);
bailIfError(KprSocketWriterNew(&self->writer, self->socket, self));
self->writer->errorCallback = KprDebugMachineWriteError;
KprDebugMachineCallbackText(self, "onMachineRegistered", mxNoCommand, NULL);
FskInstrumentedItemNew(self, NULL, &KprDebugMachineInstrumentation);
return err;
bail:
KprDebugMachineDispose(self);
return err;
}
FskErr FskSemaphoreNew_(FskSemaphore *sem, UInt32 value, FSK_SYNCHRONIZATION_DEBUG_ARGS)
#endif
{
FskErr err;
err = FskMemPtrNewClear(sizeof(FskSemaphoreRecord), (FskMemPtr *)sem);
BAIL_IF_ERR(err);
err = KplSemaphoreNew((KplSemaphore*)&(*sem)->kplSem, value);
BAIL_IF_ERR(err);
FskInstrumentedItemNew(*sem, NULL, &gFskSemaphoreTypeInstrumentation);
#if SUPPORT_INSTRUMENTATION && SUPPORT_SYNCHRONIZATION_DEBUG
if (FskInstrumentedItemHasListeners(*sem)) {
FskSynchronizationInstrMsgRecord msg;
msg.file = file;
msg.line = line;
msg.function = function;
FskInstrumentedItemSendMessage(*sem, kFskSynchronizationInstrMsgSemaphoreNew, &msg);
}
#endif
bail:
if ((err != kFskErrNone) && (*sem != NULL)) {
KplSemaphoreDispose((*sem)->kplSem);
FskMemPtrDispose(*sem);
*sem = NULL;
}
return err;
}
FskErr KprPinsNew(KprPins *it)
{
FskErr err = kFskErrNone;
bailIfError(FskMemPtrNewClear(sizeof(KprPinsRecord), it));
FskInstrumentedItemNew((KprPins)*it, NULL, &KprPinsInstrumentation);
bail:
return err;
}
static FskErr KprLibraryQueryNew(KprLibraryQuery* it)
{
FskErr err = kFskErrNone;
bailIfError(FskMemPtrNewClear(sizeof(KprLibraryQueryRecord), it));
FskInstrumentedItemNew((KprLibraryQuery)*it, NULL, &KprLibraryQueryInstrumentation);
bail:
return err;
}
FskErr KprDBStatementNew(KprDBStatement* it, KprDB db, const char* text, char* bindFormat, char* rowFormat)
{
FskErr err = kFskErrNone;
KprDBStatement self = NULL;
SInt32 count, size, i;
bailIfError(KprMemPtrNewClear(sizeof(KprDBStatementRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprDBStatementInstrumentation);
bailIfError(sqlite3_prepare_v2(db->data, text, FskStrLen(text), &self->data, NULL));
count = sqlite3_bind_parameter_count(self->data);
if (count && !bindFormat) BAIL(kFskErrInvalidParameter);
if (!count && bindFormat) BAIL(kFskErrInvalidParameter);
if (count) {
if ((SInt32)FskStrLen(bindFormat) != count) BAIL(kFskErrInvalidParameter);
self->bindFormat = FskStrDoCopy(bindFormat);
bailIfNULL(self->bindFormat);
}
count = sqlite3_column_count(self->data);
if (count && !rowFormat) BAIL(kFskErrInvalidParameter);
if (!count && rowFormat) BAIL(kFskErrInvalidParameter);
if (count) {
if ((SInt32)FskStrLen(rowFormat) != count) BAIL(kFskErrInvalidParameter);
self->rowFormat = FskStrDoCopy(rowFormat);
bailIfNULL(self->rowFormat);
bailIfError(KprMemPtrNewClear(count * sizeof(char*), &self->keys));
for (size = 0, i = 0; rowFormat[i]; i++) {
self->keys[i] = sqlite3_column_name(self->data, i);
switch (rowFormat[i]) {
case 'b':
size += sizeof(void*) + sizeof(UInt32);
break;
case 'd':
size += sizeof(double);
break;
case 'i':
size += sizeof(SInt32);
break;
case 'I':
size += sizeof(FskInt64);
break;
case 'r':
size += sizeof(SInt32);
break;
case 't':
size += sizeof(char*);
break;
default:
BAIL(kFskErrInvalidParameter);
break;
}
}
bailIfError(KprMemPtrNewClear(size, &self->values));
}
bail:
if (err)
KprDBStatementDispose(self);
return err;
}
FskErr KprHTTPConnectionNew(KprHTTPConnection* it)
{
FskErr err = kFskErrNone;
KprHTTPConnection self = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KprHTTPConnectionRecord), &self));
*it = self;
FskInstrumentedItemNew(self, NULL, &KprHTTPConnectionInstrumentation);
bail:
return err;
}
FskErr KprApplicationNew(KprApplication* it, char* url, char* id, Boolean breakOnStart, Boolean breakOnExceptions)
{
KprCoordinatesRecord coordinates = { kprLeftRight, kprTopBottom, 0, 0, 0, 0, 0, 0 };
xsAllocation allocation = {
2 * 1024 * 1024,
1024 * 1024,
64 * 1024,
8 * 1024,
2048,
16000,
1993
};
FskErr err = kFskErrNone;
KprApplication self;
bailIfError(FskMemPtrNewClear(sizeof(KprApplicationRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprApplicationInstrumentation);
self->dispatch = &KprApplicationDispatchRecord;
self->flags = kprContainer | kprClip | kprVisible;
KprContentInitialize((KprContent)self, &coordinates, NULL, NULL);
bailIfError(KprURLMerge(gShell->url, url, &self->url));
if (id) {
self->id = FskStrDoCopy(id);
bailIfNULL(self->id);
}
self->the = xsAliasMachine(&allocation, gShell->root, self->url, self);
if (!self->the)
BAIL(kFskErrMemFull);
FskInstrumentedItemSendMessageNormal(self, kprInstrumentedContentCreateMachine, self);
xsBeginHost(self->the);
xsResult = xsNewHostFunction(KPR_include, 1);
xsSet(xsResult, xsID("uri"), xsString(self->url));
xsNewHostProperty(xsGlobal, xsID("include"), xsResult, xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
xsResult = xsNewHostFunction(KPR_require, 1);
xsSet(xsResult, xsID("uri"), xsString(self->url));
xsNewHostProperty(xsGlobal, xsID("require"), xsResult, xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
xsResult = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("application")));
self->slot = xsResult;
xsSetHostData(xsResult, self);
(void)xsCall1(xsGet(xsGlobal, xsID("Object")), xsID("seal"), xsResult);
xsNewHostProperty(xsGlobal, xsID("application"), xsResult, xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
xsNewHostProperty(xsGlobal, xsID("shell"), xsNull, xsDontDelete | xsDontSet, xsDontScript | xsDontDelete | xsDontSet);
if (breakOnStart)
xsDebugger();
if (breakOnExceptions)
(void)xsCall1(xsGet(xsGet(xsGlobal, xsID("xs")), xsID("debug")), xsID("setBreakOnException"), xsBoolean(breakOnExceptions));
(void)xsCall1(xsGlobal, xsID("include"), xsString(self->url));
xsEndHost(self->the);
KprContentChainPrepend(&gShell->applicationChain, self, 0, NULL);
bail:
return err;
}
FskErr KprMessageScriptTargetNew(KprMessageScriptTarget* it, char* name)
{
KprMessageScriptTarget self;
FskErr err = kFskErrNone;
bailIfError(FskMemPtrNewClear(sizeof(KprMessageScriptTargetRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprMessageScriptTargetInstrumentation);
self->dispatch = &kprScriptTargetDispatchRecord;
self->name = FskStrDoCopy(name);
bail:
return err;
}
FskErr KprZeroconfPlatformBrowserNew(KprZeroconfBrowser self)
{
FskErr err = kFskErrNone;
KprZeroconfPlatformBrowser browser = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KprZeroconfPlatformBrowserRecord), &browser));
FskInstrumentedItemNew(browser, NULL, &KprZeroconfPlatformBrowserInstrumentation);
self->platform = browser;
bail:
if (err)
KprZeroconfPlatformBrowserDispose(self);
return err;
}
FskErr KprLibrarySessionNew(KprLibrarySession* it, FskHTTPServerRequest request)
{
FskErr err = kFskErrNone;
KprLibrarySession self = NULL;
bailIfError(KprMemPtrNewClear(sizeof(KprLibrarySessionRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprLibrarySessionInstrumentation);
FskHTTPServerRequestSetRefcon(request, self);
self->request = request;
bail:
return err;
}
static FskErr httpServerListenerStart(FskHTTPServerListener listener, FskSocket skt) {
FskErr err = kFskErrNone;
FskHTTPServerRequest request;
if (listener->http->stopped) {
FskInstrumentedItemSendMessage(listener->http, kFskHTTPInstrMsgConnectionRefusedStopped, listener);
listener->http->stats.connectionsRefused++;
FskNetSocketClose(skt);
goto bail;
}
err = FskMemPtrNewClear(sizeof(FskHTTPServerRequestRecord), (FskMemPtr*)&request);
BAIL_IF_ERR(err);
sFskHTTPServerRequestUpUse(request);
request->http = listener->http;
request->skt = skt;
FskNetSocketGetRemoteAddress(skt, (UInt32 *)&request->requesterAddress, &request->requesterPort);
FskNetSocketMakeNonblocking(request->skt);
err = FskHeaderStructNew(&request->requestHeaders);
BAIL_IF_ERR(err);
err = FskHeaderStructNew(&request->responseHeaders);
BAIL_IF_ERR(err);
request->in.bufferSize = request->http->defaultBufferSize;
request->out.bufferSize = request->http->defaultBufferSize;
err = FskMemPtrNew(request->in.bufferSize, (FskMemPtr*)&request->in.buf);
BAIL_IF_ERR(err);
err = FskMemPtrNew(request->out.bufferSize, (FskMemPtr*)&request->out.buf);
BAIL_IF_ERR(err);
FskListAppend((FskList*)&request->http->activeRequests, request);
FskTimeCallbackNew(&request->cycleCallback);
FskTimeCallbackNew(&request->keepAliveKillCallback);
listener->http->stats.connectionsMade++;
request->state = kHTTPNewSession;
FskInstrumentedItemNew(request, NULL, &gFskHTTPServerRequestTypeInstrumentation);
FskInstrumentedItemSetOwner(request, request->http);
FskTimeCallbackScheduleNextRun(request->cycleCallback, httpServerTimeCycle, request);
doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionConnectionInitialized, request->refCon);
FskTimeCallbackNew(&request->timer);
FskTimeCallbackScheduleFuture(request->timer, 1, 0, KprHTTPServerTimerCallback, request);
bail:
if (err)
FskHTTPServerRequestDispose(request);
return err;
}
FskErr KprDBNew(KprDB* it, char* path, Boolean rw)
{
FskErr err = kFskErrNone;
KprDB self = NULL;
if (!gDBCount)
bailIfError(sqlite3_initialize());
bailIfError(KprMemPtrNewClear(sizeof(KprDBRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprDBInstrumentation);
bailIfError(sqlite3_open_v2(path, &self->data, rw ? SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE : SQLITE_OPEN_READONLY, NULL));
gDBCount++;
bail:
return err;
}
FskErr KprLabelNew(KprLabel *it, KprCoordinates coordinates, KprSkin skin, KprStyle style, char* text)
{
FskErr err = kFskErrNone;
KprLabel self;
bailIfError(FskMemPtrNewClear(sizeof(KprLabelRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprLabelInstrumentation);
self->dispatch = &KprLabelDispatchRecord;
self->flags = kprVisible;
KprContentInitialize((KprContent)self, coordinates, skin, style);
KprLabelSetString(self, text);
bail:
return err;
}
FskErr KprZeroconfPlatformAdvertisementNew(KprZeroconfAdvertisement self)
{
FskErr err = kFskErrNone;
KprZeroconfPlatformAdvertisement advertisement = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KprZeroconfPlatformAdvertisementRecord), &advertisement));
FskInstrumentedItemNew(advertisement, NULL, &KprZeroconfPlatformAdvertisementInstrumentation);
self->platform = advertisement;
bail:
if (err)
KprZeroconfPlatformAdvertisementDispose(self);
return err;
}
FskErr KprMessageNew(KprMessage *it, char* url)
{
FskErr err = kFskErrNone;
KprMessage self;
bailIfError(FskMemPtrNewClear(sizeof(KprMessageRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprMessageInstrumentation);
self->url = FskStrDoCopy(url);
bailIfNULL(self->url);
KprURLSplit(self->url, &self->parts);
self->priority = 256;
bail:
return err;
}
FskErr FskAudioDecompressNew(FskAudioDecompress *decoOut, UInt32 audioFormat, const char *mimeType, UInt32 sampleRate, UInt32 channelCount, void *formatInfo, UInt32 formatInfoSize)
{
FskErr err;
FskAudioDecompressor decoder;
FskAudioDecompress deco;
UInt32 i = 0;
while (true) {
Boolean canHandle = false;
decoder = (FskAudioDecompressor)FskExtensionGetByIndex(kFskExtensionAudioDecompressor, i++);
if (NULL == decoder) {
if (decoOut)
*decoOut = NULL;
return kFskErrExtensionNotFound;
}
if ((kFskErrNone == decoder->doCanHandle(audioFormat, mimeType, &canHandle)) && canHandle)
break;
}
if (NULL == decoOut)
return kFskErrNone; // can handler
err = FskMemPtrNewClear(sizeof(FskAudioDecompressRecord), &deco);
BAIL_IF_ERR(err);
deco->inputSampleRate = sampleRate;
deco->inputChannelCount = channelCount;
deco->outputChannelCount = channelCount;
deco->formatInfoSize = formatInfoSize;
err = FskMemPtrNewFromData(formatInfoSize, formatInfo, (FskMemPtr*)(void*)&deco->formatInfo);
BAIL_IF_ERR(err);
deco->decoder = decoder;
FskInstrumentedItemNew(deco, FskStrDoCopy_Untracked(mimeType), &gAudioDecompressTypeInstrumentation);
err = deco->decoder->doNew(deco, audioFormat, mimeType);
BAIL_IF_ERR(err);
bail:
if (err) {
FskAudioDecompressDispose(deco);
deco = NULL;
}
*decoOut = deco;
return err;
}
FskErr KprHostNew(KprHost* it, KprCoordinates coordinates, char* url, char* id, Boolean breakOnStart, Boolean breakOnExceptions)
{
FskErr err = kFskErrNone;
KprHost self = NULL;
KprApplication application = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KprHostRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprHostInstrumentation);
self->dispatch = &KprHostDispatchRecord;
self->flags = kprHost | kprContainer | kprClip | kprVisible;
KprContentInitialize((KprContent)self, coordinates, NULL, NULL);
bailIfError(KprApplicationNew(&application, url, id, breakOnStart, breakOnExceptions));
KprContainerAdd((KprContainer)self, (KprContent)application);
bail:
return err;
}
FskErr KprSSDPClientNew(KprSSDPClient *it, const char* type)
{
FskErr err = kFskErrNone;
KprSSDPClient self = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KprSSDPClientRecord), it));
self = *it;
if (type) {
self->type = FskStrDoCopy(type);
bailIfNULL(self->type);
}
FskInstrumentedItemNew(self, NULL, &KprSSDPClientInstrumentation);
bail:
if (err)
KprSSDPClientDispose(self);
return err;
}
/*
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 KprDebugNew(KprDebug* it, UInt32 port)
{
FskErr err = kFskErrNone;
KprDebug self = NULL;
BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KprDebugRecord), it));
self = *it;
self->port = port;
BAIL_IF_ERR(err = KprSocketServerNew(&self->server, self));
self->server->debugName = "Debug";
self->server->acceptCallback = KprDebugAcceptNewConnection;
BAIL_IF_ERR(err = KprSocketServerListen(self->server, self->port, NULL));
FskListAppend(&gKprDebugList, self);
FskInstrumentedItemNew(self, NULL, &KprDebugInstrumentation);
return err;
bail:
KprDebugDispose(self);
return err;
}
FskErr KprWebSocketEndpointNew(KprWebSocketEndpoint* it, void *refcon)
{
FskErr err = kFskErrNone;
KprWebSocketEndpoint self = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KprWebSocketEndpointRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &gKprWebSocketEndpointInstrumentation);
self->refcon = refcon;
self->state = kKprWebSocketStateConnecting;
FskDebugStr("CREATE: KprWebSocketEndpoint\n");
return err;
bail:
if (self) KprWebSocketEndpointDispose(self);
return err;
}
FskErr KprCanvasNew(KprCanvas* it, KprCoordinates coordinates)
{
FskErr err = kFskErrNone;
KprCanvas self;
bailIfError(FskMemPtrNewClear(sizeof(KprCanvasRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprCanvasInstrumentation);
self->dispatch = &KprCanvasDispatchRecord;
self->flags = kprVisible;
KprContentInitialize((KprContent)self, coordinates, NULL, NULL);
if (coordinates->width && coordinates->height) {
bailIfError(FskCanvasNew(coordinates->width, coordinates->height, PreferredPixelFormat(), &self->cnv));
FskCanvas2dSetOpenGLSourceAccelerated(self->cnv, true);
}
bail:
return err;
}
FskErr FskMutexNew_(FskMutex *mutex, const char *name, FSK_SYNCHRONIZATION_DEBUG_ARGS)
#endif
{
FskMutex mtx = NULL;
FskErr err;
err = FskMemPtrNewClear(sizeof(FskMutexRecord), (FskMemPtr *)&mtx);
BAIL_IF_ERR(err);
err = KplMutexNew((KplMutex*)&mtx->kplMutex);
BAIL_IF_ERR(err);
#if SUPPORT_INSTRUMENTATION
mtx->name = FskStrDoCopy_Untracked(name);
FskInstrumentedItemNew(mtx, mtx->name, &gFskMutexTypeInstrumentation);
#if SUPPORT_SYNCHRONIZATION_DEBUG
if (FskInstrumentedItemHasListeners(mtx)) {
FskSynchronizationInstrMsgRecord msg;
msg.name = name;
msg.file = file;
msg.line = line;
msg.function = function;
FskInstrumentedItemSendMessage(mtx, kFskSynchronizationInstrMsgMutexNew, &msg);
}
#endif
#endif
bail:
if ((err != kFskErrNone) && (mtx != NULL)) {
KplMutexDispose(mtx->kplMutex);
#if SUPPORT_INSTRUMENTATION
FskMemPtrDispose_Untracked((void*)mtx->name);
#endif
FskMemPtrDispose(mtx);
mtx = NULL;
}
*mutex = mtx;
return err;
}
FskErr FskMutexNew_(FskMutex *mutex, const char *name, FSK_SYNCHRONIZATION_DEBUG_ARGS)
#endif
{
FskErr err;
pthread_mutexattr_t attr;
err = FskMemPtrNewClear(sizeof(FskMutexRecord), (FskMemPtr *)mutex);
BAIL_IF_ERR(err);
if ((pthread_mutexattr_init(&attr) != 0) ||
(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0) ||
(pthread_mutex_init(&(*mutex)->mutex, &attr) != 0)) {
BAIL(kFskErrOperationFailed);
}
#if SUPPORT_INSTRUMENTATION
(*mutex)->name = FskStrDoCopy_Untracked(name);
FskInstrumentedItemNew(*mutex, NULL, &gFskMutexTypeInstrumentation);
#if SUPPORT_SYNCHRONIZATION_DEBUG
if (FskInstrumentedItemHasListeners(*mutex)) {
FskSynchronizationInstrMsgRecord msg;
msg.name = name;
msg.file = file;
msg.line = line;
msg.function = function;
FskInstrumentedItemSendMessage(*mutex, kFskSynchronizationInstrMsgMutexNew, &msg);
}
#endif
#endif
bail:
pthread_mutexattr_destroy(&attr);
if ((err != kFskErrNone) && (*mutex != NULL)) {
#if SUPPORT_INSTRUMENTATION
FskMemPtrDispose((FskMemPtr)(*mutex)->name);
#endif
FskMemPtrDispose(*mutex);
*mutex = NULL;
}
return err;
}
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;
}
FskErr KprSoundNew(KprSound *it, KprContext context, char* base, char* url, char* mime)
{
FskErr err = kFskErrNone;
KprSound self;
KprSoundSetup();
bailIfError(KprAssetNew((KprAsset *)it, sizeof(KprSoundRecord), context, &context->firstSound, KprSoundDispose));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprSoundInstrumentation);
#if SUPPORT_INSTRUMENTATION
FskInstrumentedItemSetOwner(self, context);
#endif
if (base && url)
bailIfError(KprURLMerge(base, url, &self->url));
if (mime) {
self->mime = FskStrDoCopy(mime);
bailIfNULL(self->mime);
}
bail:
return err;
}
FskErr FskAudioFilterNew(FskAudioFilter *filterOut, const char *filterType)
{
FskErr err = kFskErrNone;
FskAudioFilter filter = NULL;
UInt32 i = 0;
FskAudioFilterDispatch dispatch;
while (true) {
dispatch = (FskAudioFilterDispatch)FskExtensionGetByIndex(kFskExtensionAudioFilter, i++);
if (NULL == dispatch)
return kFskErrUnimplemented;
if (dispatch->doCanHandle(filterType))
break;
}
if (NULL == filterOut) goto bail; // "can handle" request
err = FskMemPtrNewClear(sizeof(FskAudioFilterRecord) + FskStrLen(filterType) + 1, &filter);
BAIL_IF_ERR(err);
filter->filterType = (char *)(filter + 1);
FskStrCopy(filter->filterType, filterType);
filter->dispatch = dispatch;
FskInstrumentedItemNew(filter, filter->filterType, &gAudioFilterTypeInstrumentation);
err = (filter->dispatch->doNew)(filter, &filter->state);
BAIL_IF_ERR(err);
bail:
if (kFskErrNone != err) {
FskAudioFilterDispose(filter);
filter = NULL;
}
if (NULL != filterOut)
*filterOut = filter;
return err;
}
FskErr FskSemaphoreNew_(FskSemaphore *sem, UInt32 value, FSK_SYNCHRONIZATION_DEBUG_ARGS)
#endif
{
FskErr err;
err = FskMemPtrNewClear(sizeof(FskSemaphoreRecord), (FskMemPtr *)sem);
BAIL_IF_ERR(err);
#if TARGET_OS_MAC
{
FskSemaphore s = *sem;
snprintf(s->name, sizeof(s->name)-1, "/tmp/sem%lx", (unsigned long)s);
if ((s->hSem = sem_open(s->name, O_CREAT|O_EXCL, 666, value)) == NULL) {
BAIL(kFskErrOperationFailed);
}
}
#else
if (sem_init(&(*sem)->hSem, 0, value) != 0) {
BAIL(kFskErrOperationFailed);
}
#endif
FskInstrumentedItemNew(*sem, NULL, &gFskSemaphoreTypeInstrumentation);
#if SUPPORT_INSTRUMENTATION && SUPPORT_SYNCHRONIZATION_DEBUG
if (FskInstrumentedItemHasListeners(*sem)) {
FskSynchronizationInstrMsgRecord msg;
msg.file = file;
msg.line = line;
msg.function = function;
FskInstrumentedItemSendMessage(*sem, kFskSynchronizationInstrMsgSemaphoreNew, &msg);
}
#endif
bail:
if ((err != kFskErrNone) && (*sem != NULL)) {
FskMemPtrDispose(*sem);
*sem = NULL;
}
return err;
}
FskErr KprLibraryServerNew(KprLibraryServer* it)
{
FskErr err = kFskErrNone;
KprLibraryServer self = NULL;
FskTimeRecord now;
bailIfError(KprMemPtrNewClear(sizeof(KprLibraryServerRecord), it));
self = *it;
FskInstrumentedItemNew(self, NULL, &KprLibraryServerInstrumentation);
self->vectors.requestCondition = KprLibraryServerRequestConditionCallback;
self->vectors.requestReceiveRequest = KprLibraryServerRequestBodyCallback;
self->vectors.requestGenerateResponseBody = KprLibraryServerResponseBodyCallback;
FskMutexNew(&self->queryMutex, "query");
FskTimeGetNow(&now);
self->queryIndex = FskTimeInSecs(&now);
gLibraryServer = self;
bail:
return err;
}
