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); }
void KprZeroconfServiceShare(KprService self, char* authority, Boolean shareIt, Boolean useEnvironment) { FskErr err = kFskErrNone; char* type = NULL; KprZeroconfAdvertisement advertisement = NULL; KprHTTPServer server = KprHTTPServerGet(authority); bailIfError(KprZeroconfServiceNewType(authority, &type)); advertisement = KprZeroconfAdvertisementFind(gKprZeroconfAdvertisements, type, 0); if (shareIt && useEnvironment) shareIt = KprEnvironmentGetUInt32("useZeroconf", 0); if (shareIt && server) { if (!advertisement) { UInt32 port = server ? KprHTTPServerGetPort(server) : 0; Boolean secure = server ? KprHTTPServerIsSecure(server) : false; char* uuid = FskUUIDGetForKey(authority); FskAssociativeArray txt = NULL; if (secure) { txt = FskAssociativeArrayNew(); FskAssociativeArrayElementSetString(txt, "secure", "true"); } bailIfError(KprZeroconfAdvertisementNew(&advertisement, type, uuid, port, txt)); bailIfError(KprZeroconfPlatformAdvertisementStart(advertisement)); FskListAppend(&gKprZeroconfAdvertisements, advertisement); } } else { if (advertisement) { FskListRemove(&gKprZeroconfAdvertisements, advertisement); bailIfError(KprZeroconfPlatformAdvertisementStop(advertisement)); KprZeroconfAdvertisementDispose(advertisement); } } bail: if (err) KprZeroconfAdvertisementDispose(advertisement); FskMemPtrDispose(type); FskMemPtrDispose(authority); return; }
void Zeroconf_Advertisement(xsMachine *the) { KprZeroconfAdvertisement self = NULL; char* serviceType = xsToString(xsArg(0)); char* servicName = xsToString(xsArg(1)); int servicPort = xsToInteger(xsArg(2)); xsIntegerValue c = xsToInteger(xsArgc); FskAssociativeArray txt = NULL; if ((c > 3) && xsIsInstanceOf(xsArg(3), xsObjectPrototype)) { xsVars(2); xsEnterSandbox(); fxPush(xsArg(3)); fxRunForIn(the); txt = FskAssociativeArrayNew(); for (xsVar(0) = fxPop(); xsTypeOf(xsVar(0)) != xsNullType; xsVar(0) = fxPop()) { if (xsTypeOf(xsVar(0)) == xsStringType) { xsVar(1) = xsGetAt(xsArg(3), xsVar(0)); if (!xsIsInstanceOf(xsVar(1), xsObjectPrototype)) { char* name = xsToString(xsVar(0)); char* value = xsToString(xsVar(1)); FskAssociativeArrayElementSetString(txt, name, value); } } } xsLeaveSandbox(); } xsThrowIfFskErr(KprZeroconfAdvertisementNew(&self, serviceType, servicName, servicPort, txt)); xsSetHostData(xsResult, self); self->registeredCallback = Zeroconf_advertisement_registeredCallback; self->unregisteredCallback = Zeroconf_advertisement_unregisteredCallback; self->the = the; self->slot = xsResult; self->code = the->code; self->behavior = xsUndefined; xsRemember(self->slot); }
char *FskUUIDGetForKey(const char *key) { char *uuidStr; FskUUIDRecord uuid; char *uuidCachePath = NULL, *prefFolder; FskFile fref; if (kFskErrNone == FskDirectoryGetSpecialPath(kFskDirectorySpecialTypeApplicationPreference, true, NULL, &prefFolder)) { uuidCachePath = FskStrDoCat(prefFolder, "fskuuidcache.txt"); FskMemPtrDispose(prefFolder); } // load the cache if (NULL == gUUIDCache) { char *uuidCache; FskInt64 cacheSize; gUUIDCache = FskAssociativeArrayNew(); if ((NULL != uuidCachePath) && (kFskErrNone == FskFileLoad(uuidCachePath, (unsigned char **)(void *)&uuidCache, &cacheSize))) { char *p = uuidCache; while (true) { char *uuid = p; char *mykey = FskStrChr(p, '\t'); char *cr; if (NULL == mykey) break; cr = FskStrChr(mykey, '\n'); if (NULL == cr) break; *mykey++ = 0; *cr = 0; FskAssociativeArrayElementSetString(gUUIDCache, mykey, uuid); p = cr + 1; } FskMemPtrDispose(uuidCache); } } // check the cache uuidStr = FskAssociativeArrayElementGetString(gUUIDCache, key); if (uuidStr) { FskMemPtrDispose(uuidCachePath); return uuidStr; } // not in cache FskUUIDCreate(&uuid); uuidStr = FskUUIDtoString_844412(&uuid); FskAssociativeArrayElementSetString(gUUIDCache, key, uuidStr); FskMemPtrDispose(uuidStr); // flush cache FskFileDelete(uuidCachePath); FskFileCreate(uuidCachePath); if (kFskErrNone == FskFileOpen(uuidCachePath, kFskFilePermissionReadWrite, &fref)) { FskAssociativeArrayIterator iterate = FskAssociativeArrayIteratorNew(gUUIDCache); char tab = '\t', cr = '\n'; while (iterate) { FskFileWrite(fref, FskStrLen(iterate->value), iterate->value, NULL); FskFileWrite(fref, 1, &tab, NULL); FskFileWrite(fref, FskStrLen(iterate->name), iterate->name, NULL); FskFileWrite(fref, 1, &cr, NULL); iterate = FskAssociativeArrayIteratorNext(iterate); } FskFileClose(fref); } FskMemPtrDispose(uuidCachePath); return FskAssociativeArrayElementGetString(gUUIDCache, key); // caller doesn't have to dispose }
// ------------------------------------------------------------------------ static int sParseStartLine(char *startLine, UInt16 headerType, FskHeaders *headers) { FskErr err; int l; const char *p; char *c = startLine; char *firstPart; // Get method or protocol p = c; c = FskStrChr(c, ' '); if (!c) return -1; l = (c++) - p; err = FskMemPtrNew(l+1, &firstPart); if (err != kFskErrNone) return -1; FskStrNCopy(firstPart, p, l); firstPart[l] = '\0'; if (kFskHeaderTypeResponse == headerType) headers->protocol = firstPart; else headers->method = firstPart; c = FskStrStripHeadSpace(c); // skip over space headers->headerType = headerType; if (kFskHeaderTypeResponse == headerType) { // Get response code and message (if message not in HTTP_Responses) headers->responseCode = FskStrToNum(c); if (headers->flags & kFskHeadersNonStandardResponseReasonPhrase) { c = FskStrChr(c, ' '); if (c) { char *r, *s; s = FskStrStripHeadSpace(c); r = FskFindResponse(headers->responseCode); if (!r || (0 != FskStrCompareCaseInsensitiveWithLength(s, r, FskStrLen(r)))) { headers->responseReasonPhrase = FskStrDoCopy(s); if (NULL != headers->responseReasonPhrase) FskStrStripTailSpace(headers->responseReasonPhrase); } } } } else { char *s, *t = NULL; char *uri = NULL; // Get URI if ((*c == '/') && !(headers->flags & kFskHeadersDoNotStripURILeadingSlash)) c++; s = FskStrChr(c, ' '); if (!s) { headers->responseCode = 400; return -1; } headers->protocol = FskStrDoCopy(s + 1); if (NULL != headers->protocol) FskStrStripTailSpace(headers->protocol); BAIL_IF_ERR(FskMemPtrNew((s-c)+1, &uri)); BAIL_IF_ERR(FskMemPtrNew((s-c)+1, &t)); FskMemCopy(uri, c, s-c); uri[s-c] = '\0'; s = FskStrChr(uri, '?'); if (s) *s = 0; FskStrDecodeEscapedChars(uri, t); if (s) { *s = '?'; FskStrCat(t, s); } headers->URI = FskStrDoCopy(t); // Break URI into filename and parameters s = FskStrChr(t, '?'); if (!s) { headers->filename = FskStrDoCopy(t); } else { // URI has parameters *s++ = '\0'; // cap off the filename headers->filename = FskStrDoCopy(t); headers->parameters = FskAssociativeArrayNew(); while (s) { char *name = s; char *value = FskStrChr(name, '='); if (!value) break; s = FskStrChr(value, '&'); *value++ = '\0'; // cap off the name if (s) *s++ = '\0'; // cap off the value FskAssociativeArrayElementSetString(headers->parameters, name, value); } } bail: FskMemPtrDispose(uri); FskMemPtrDispose(t); } return headers->headerType; }