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