FskErr
FskSSLNew(void **fsslp, const char *host, int port, Boolean blocking, long flags, int priority)
{
FskSSL *fssl;
FskErr err;
if ((err = FskMemPtrNewClear(sizeof(FskSSL), (FskMemPtr*)(void*)&fssl)) != kFskErrNone)
return err;
if ((err = newSSLVM(&fssl->vm)) != kFskErrNone) {
FskMemPtrDispose(fssl);
return err;
}
xsBeginHost(fssl->vm->the);
xsTry {
const char *prStr;
xsVars(2);
/* construct the options */
xsVar(0) = xsNewInstanceOf(xsObjectPrototype);
if (blocking)
xsSet(xsVar(0), xsID("blocking"), xsTrue);
if (flags & kConnectFlagsSynchronous)
xsSet(xsVar(0), xsID("synchronous"), xsTrue);
switch (priority) {
default:
case kFskNetSocketLowestPriority: prStr = "lowest"; break;
case kFskNetSocketLowPriority: prStr = "low"; break;
case kFskNetSocketMediumPriority: prStr = "medium"; break;
case kFskNetSocketHighPriority: prStr = "high"; break;
case kFskNetSocketHighestPriority: prStr = "highest"; break;
}
(void)xsSet(xsVar(0), xsID("priority"), xsString((xsStringValue)prStr));
(void)xsSet(xsVar(0), xsID("raw"), xsTrue);
xsVar(1) = xsNew3(xsGet(xsGlobal, xsID("Stream")), xsID("Socket"), xsString((xsStringValue)host), xsInteger(port), xsVar(0));
fssl->socket = xsVar(1); xsRemember(fssl->socket);
xsVar(1) = xsNew0(xsGet(xsGlobal, xsID("FskSSL")), xsID("Session"));
fssl->ssl = xsVar(1); xsRemember(fssl->ssl);
} xsCatch {
if (xsHas(xsException, xsID("code")))
err = xsToInteger(xsGet(xsException, xsID("code")));
if (err == kFskErrNone)
err = kFskErrOperationFailed;
}
xsEndHost(fssl->vm->the);
if (err == kFskErrNone) {
if (fsslp != NULL)
*fsslp = fssl;
}
else {
disposeSSLVM(fssl->vm);
FskMemPtrDispose(fssl);
}
return err;
}
void KPR_MQTTClient(xsMachine* the)
{
FskErr err;
KPR_MQTTClientRecord *self = NULL;
xsIntegerValue c = xsToInteger(xsArgc);
KprMQTTClient client = NULL;
char clientIdentifier[kKprMQTTClientIdentifierMaxLength + 1];
Boolean cleanSession = true;
if (c >= 1) {
char *arg = xsToString(xsArg(0));
UInt32 len = FskStrLen(arg);
if (len < 1 || len > kKprMQTTClientIdentifierMaxLength) xsThrowIfFskErr(kFskErrBadData);
FskStrCopy(clientIdentifier, arg);
} else {
char hex[9];
FskStrNumToHex(FskRandom(), hex, 8);
FskStrCopy(clientIdentifier, kKprMQTTClientIdentifierPrefix);
FskStrCat(clientIdentifier, hex);
}
if (c >= 2) {
cleanSession = xsToBoolean(xsArg(1));
}
bailIfError(FskMemPtrNewClear(sizeof(KPR_MQTTClientRecord), &self));
bailIfError(KprMQTTClientNew(&client, clientIdentifier, cleanSession, self));
client->connectCallback = KPR_mqttclient_onConnect;
client->subscribeCallback = KPR_mqttclient_onSubscribe;
client->unsubscribeCallback = KPR_mqttclient_onUnsubscribe;
client->publishCallback = KPR_mqttclient_onPublish;
client->messageCallback = KPR_mqttclient_onMessage;
client->disconnectCallback = KPR_mqttclient_onDisconnect;
client->errorCallback = KPR_mqttclient_onError;
self->client = client;
self->the = the;
self->slot = xsThis;
self->code = the->code;
xsSetHostData(self->slot, self);
// xsCall1(xsGet(xsGlobal, xsID_Object), xsID_seal, self->slot);
xsRemember(self->slot);
bail:
if (err) {
KprMQTTClientDispose(client);
FskMemPtrDispose(self);
xsThrowIfFskErr(err);
}
}
void KPR_debug_set_behavior(xsMachine *the)
{
KprDebug self = xsGetHostData(xsThis);
xsForget(self->behavior);
if (xsTest(xsArg(0))) {
if (xsIsInstanceOf(xsArg(0), xsObjectPrototype)) {
self->behavior = xsArg(0);
xsRemember(self->behavior);
}
}
}
FskErr
FskSSLAttach(void **fsslp, FskSocket skt)
{
FskSSL *fssl;
FskErr err;
if ((err = FskMemPtrNewClear(sizeof(FskSSL), (FskMemPtr*)(void*)&fssl)) != kFskErrNone)
return err;
if ((err = newSSLVM(&fssl->vm)) != kFskErrNone) {
FskMemPtrDispose(fssl);
return err;
}
xsBeginHost(fssl->vm->the);
xsTry {
xsVars(2);
xsVar(0) = xsNew1(xsGet(xsGlobal, xsID("Stream")), xsID("Socket"), xsHostData(skt));
xsVar(1) = xsNewInstanceOf(xsObjectPrototype);
(void)xsSet(xsVar(1), xsID("raw"), xsTrue);
xsCall1_noResult(xsVar(0), xsID("setProperties"), xsVar(1));
fssl->socket = xsVar(0); xsRemember(fssl->socket);
xsVar(0) = xsNew0(xsGet(xsGlobal, xsID("FskSSL")), xsID("Session"));
fssl->ssl = xsVar(0); xsRemember(fssl->ssl);
} xsCatch {
if (xsHas(xsException, xsID("code")))
err = xsToInteger(xsGet(xsException, xsID("code")));
if (err == kFskErrNone)
err = kFskErrOperationFailed;
}
xsEndHost(fssl->vm->the);
if (err == kFskErrNone) {
if (fsslp != NULL)
*fsslp = fssl;
}
else {
disposeSSLVM(fssl->vm);
FskMemPtrDispose(fssl);
}
return err;
}
void Zeroconf_set_behavior(xsMachine *the)
{
KprZeroconfCommon self = xsGetHostData(xsThis);
xsForget(self->behavior);
self->behavior = xsUndefined;
if (xsTest(xsArg(0))) {
if (xsIsInstanceOf(xsArg(0), xsObjectPrototype)) {
self->behavior = xsArg(0);
xsRemember(self->behavior);
}
}
}
void KPR_Debug(xsMachine *the)
{
KprDebug self = NULL;
UInt32 port = 0;
xsEnterSandbox();
if (xsIsInstanceOf(xsArg(0), xsObjectPrototype)) {
(void)(xsFindInteger(xsArg(0), xsID_port, &port));
// add behavior?
}
xsLeaveSandbox();
xsThrowIfFskErr(KprDebugNew(&self, port));
xsSetHostData(xsResult, self);
self->the = the;
self->slot = xsResult;
self->code = the->code;
self->behavior = xsUndefined;
xsRemember(self->slot);
return;
}
void Zeroconf_Browser(xsMachine *the)
{
KprZeroconfBrowser self = NULL;
xsTry {
char* serviveType = NULL;
if (xsTest(xsArg(0)))
serviveType = xsToString(xsArg(0));
xsThrowIfFskErr(KprZeroconfBrowserNew(&self, serviveType));
xsSetHostData(xsResult, self);
self->serviceUpCallback = Zeroconf_browser_serviceUpCallback;
self->serviceDownCallback = Zeroconf_browser_serviceDownCallback;
self->the = the;
self->slot = xsResult;
self->code = the->code;
self->behavior = xsUndefined;
xsRemember(self->slot);
}
xsCatch {
}
}
void KPR_WebSocketClient(xsMachine* the)
{
FskErr err;
xsIntegerValue c = xsToInteger(xsArgc);
KPR_WebSocketClientRecord *self = NULL;
KprWebSocketEndpoint endpoint = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KPR_WebSocketClientRecord), &self));
xsThrowIfFskErr(KprWebSocketEndpointNew(&endpoint, self));
endpoint->openCallback = KPR_WebSocketClient_onOpen;
endpoint->closeCallback = KPR_WebSocketClient_onClose;
endpoint->textCallback = KPR_WebSocketClient_onTextMessage;
endpoint->binaryCallback = KPR_WebSocketClient_onBinaryMessage;
endpoint->errorCallback = KPR_WebSocketClient_onError;
self->endpoint = endpoint;
self->the = the;
self->slot = xsThis;
self->code = the->code;
xsSetHostData(self->slot, self);
// xsCall1(xsGet(xsGlobal, xsID_Object), xsID_seal, self->slot);
if (c >= 1) {
bailIfError(KprWebSocketEndpointConnect(endpoint, xsToString(xsArg(0)), NULL));
}
xsRemember(self->slot);
return;
bail:
KprWebSocketEndpointDispose(endpoint);
FskMemPtrDispose(self);
xsThrowIfFskErr(err);
}
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);
}
void KPR_shell_execute(xsMachine* the)
{
xsStringValue application = NULL;
xsStringValue command = NULL;
xsStringValue directory = NULL;
xsStringValue environment = NULL;
xsStringValue string;
xsIntegerValue length;
KprShellExec exec = NULL;
STARTUPINFO si;
SECURITY_ATTRIBUTES sa;
xsVars(5);
xsTry {
application = getenv("COMSPEC");
if (!application)
xsThrowIfFskErr(kFskErrOperationFailed);
string = xsToString(xsArg(0));
length = FskStrLen(string) + 1;
xsThrowIfFskErr(FskMemPtrNew(3 + length, &command));
memcpy(command, "/c ", 3);
memcpy(command + 3, string, length);
if (xsFindString(xsArg(1), xsID_directory, &string)) {
length = FskStrLen(string) + 1;
xsThrowIfFskErr(FskMemPtrNew(length, &directory));
memcpy(directory, string, length);
}
if (xsFindResult(xsArg(1), xsID_environment)) {
xsIntegerValue total = 0, length;
xsVar(1) = xsEnumerate(xsResult);
for (;;) {
xsVar(2) = xsCall0(xsVar(1), xsID("next"));
xsVar(3) = xsGet(xsVar(2), xsID("done"));
if (xsTest(xsVar(3)))
break;
xsVar(3) = xsGet(xsVar(2), xsID("value"));
xsVar(4) = xsGetAt(xsResult, xsVar(3));
total += FskStrLen(xsToString(xsVar(3)));
total++;
total += FskStrLen(xsToString(xsVar(4)));
total++;
}
total++;
xsThrowIfFskErr(FskMemPtrNew(total, &environment));
total = 0;
xsVar(1) = xsEnumerate(xsResult);
for (;;) {
xsVar(2) = xsCall0(xsVar(1), xsID("next"));
xsVar(3) = xsGet(xsVar(2), xsID("done"));
if (xsTest(xsVar(3)))
break;
xsVar(3) = xsGet(xsVar(2), xsID("value"));
xsVar(4) = xsGetAt(xsResult, xsVar(3));
string = xsToString(xsVar(3));
length = FskStrLen(string);
memcpy(environment + total, string, length);
total += length;
environment[total++] = '=';
string = xsToString(xsVar(4));
length = FskStrLen(string);
memcpy(environment + total, string, length);
total += length;
environment[total++] = 0;
}
environment[total++] = 0;
}
xsThrowIfFskErr(FskMemPtrNewClear(sizeof(KprShellExecRecord), &exec));
xsVar(0) = xsNewHostObject(KPR_shell_execute_destructor);
exec->the = the;
exec->slot = xsVar(0);
xsSetHostData(xsVar(0), exec);
xsResult = xsNewHostFunction(KPR_shell_execute_cancel, 0);
xsNewHostProperty(xsVar(0), xsID_cancel, xsResult, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
if (xsFindResult(xsArg(1), xsID_callback)) {
xsNewHostProperty(xsVar(0), xsID_callback, xsResult, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
else {
xsNewHostProperty(xsVar(0), xsID_callback, xsNull, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
if (xsFindResult(xsArg(1), xsID_stderr)) {
xsNewHostProperty(xsVar(0), xsID_stderr, xsResult, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
else {
xsNewHostProperty(xsVar(0), xsID_stderr, xsNull, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
if (xsFindResult(xsArg(1), xsID_stdout)) {
xsNewHostProperty(xsVar(0), xsID_stdout, xsResult, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
else {
xsNewHostProperty(xsVar(0), xsID_stdout, xsNull, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
if (!CreatePipe(&(exec->hReadPipe), &(exec->hWritePipe), &sa, 0))
xsThrowIfFskErr(kFskErrOperationFailed);
if (!SetHandleInformation(exec->hReadPipe, HANDLE_FLAG_INHERIT, 0))
xsThrowIfFskErr(kFskErrOperationFailed);
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(STARTUPINFO);
si.hStdError = exec->hWritePipe;
si.hStdOutput = exec->hWritePipe;
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
si.dwFlags = STARTF_USESTDHANDLES;
if (!CreateProcess(application, command, NULL, NULL, TRUE, CREATE_NO_WINDOW, environment, directory, &si, &(exec->pi)))
xsThrowIfFskErr(kFskErrOperationFailed);
xsRemember(exec->slot);
exec->usage++;
FskThreadPostCallback(KprHTTPGetThread(), (FskThreadCallback)KPR_shell_execute_async, exec, NULL, NULL, NULL);
FskMemPtrDispose(environment);
FskMemPtrDispose(directory);
FskMemPtrDispose(command);
}
xsCatch {
if (exec) {
if (exec->pi.hProcess)
CloseHandle(exec->pi.hProcess);
if (exec->pi.hThread)
CloseHandle(exec->pi.hThread);
if (exec->hWritePipe)
CloseHandle(exec->hWritePipe);
if (exec->hReadPipe)
CloseHandle(exec->hReadPipe);
FskMemPtrDispose(exec);
}
FskMemPtrDispose(environment);
FskMemPtrDispose(directory);
FskMemPtrDispose(command);
xsThrow(xsException);
}
}
