void xsToolReportError(xsMachine* the)
{
char* aPath;
long aLine;
int aCount;
if (xsTypeOf(xsArg(0)) == xsStringType) {
aPath = xsToString(xsArg(0));
aLine = xsToInteger(xsArg(1));
#if mxWindows
fprintf(stderr, "%s(%ld): error: ", aPath, aLine);
#else
fprintf(stderr, "%s:%ld: error: ", aPath, aLine);
#endif
}
fprintf(stderr, "%s!\n", xsToString(xsArg(2)));
aCount = xsToInteger(xsGet(xsThis, xsID("errorCount")));
xsSet(xsThis, xsID("errorCount"), xsInteger(aCount + 1));
}
void KprDebugMachineSetViewTitle(KprDebugMachine self, int theView, char* theTitle)
{
KprDebug debug = self->debug;
xsMachine* the = debug->the;
// FskDebugStr("%s: %d - %s", __FUNCTION__, theView, theTitle);
if (xsTypeOf(debug->behavior) == xsUndefinedType) goto bail;
{
xsTry {
xsVar(0) = xsAccess(debug->behavior);
xsVar(1) = xsGet(xsVar(0), xsID(self->address));
if (xsFindResult(xsVar(0), xsID("onMachineViewTitle")))
(void)xsCallFunction3(xsResult, xsVar(0), xsString(self->address), xsInteger(theView), xsString(theTitle));
}
xsCatch {
}
}
bail:
return;
}
void
xs_curve25519_dh(xsMachine *the)
{
void *secret, *basepoint;
xsIntegerValue sz;
xsResult = xsNew1(xsGlobal, xsID("Chunk"), xsInteger(32));
getChunkData(the, &xsArg(0), &secret, &sz);
if (sz != 32)
cryptThrowFSK(kFskErrInvalidParameter);
if (xsToInteger(xsArgc) > 1) {
getChunkData(the, &xsArg(1), &basepoint, &sz);
if (sz != 32)
cryptThrowFSK(kFskErrInvalidParameter);
}
else
basepoint = (void *)c25519_base_x;
c25519_prepare(secret);
c25519_smult(xsGetHostData(xsResult), basepoint, secret);
}
void KprDebugMachineCallbackView(KprDebugMachine machine, char* function, int view)
{
KprDebug self = machine->debug;
xsMachine* the = self->the;
if (xsTypeOf(self->behavior) == xsUndefinedType) goto bail;
{
xsTry {
xsVar(0) = xsAccess(self->behavior);
if (xsFindResult(xsVar(0), xsID(function))) {
xsVar(1) = xsGet(xsVar(0), xsID(machine->address));
xsDelete(xsVar(0), xsID(machine->address));
(void)xsCallFunction3(xsResult, xsVar(0), xsString(machine->address), xsInteger(view), xsVar(1));
}
}
xsCatch {
}
}
bail:
return;
}
void KprDebugMachineCallbackText(KprDebugMachine machine, char* function, int view, char* text)
{
KprDebug self = machine->debug;
xsMachine* the = self->the;
if (xsTypeOf(self->behavior) == xsUndefinedType) goto bail;
{
xsTry {
xsVar(0) = xsAccess(self->behavior);
if (xsFindResult(xsVar(0), xsID(function))) {
if (view >= 0)
(void)xsCallFunction3(xsResult, xsVar(0), xsString(machine->address), xsInteger(view), xsString(text));
else if (text)
(void)xsCallFunction2(xsResult, xsVar(0), xsString(machine->address), xsString(text));
else
(void)xsCallFunction1(xsResult, xsVar(0), xsString(machine->address));
}
}
xsCatch {
}
}
bail:
return;
}
void KprMessageScriptTargetGet(KprMessage self, xsMachine* the, xsSlot* slot)
{
if (self->stream->dispatch->dispose == KprMessageScriptTargetDispose) {
KprMessageScriptTarget target = (KprMessageScriptTarget)self->stream;
if (target->result)
*slot = xsDemarshall(target->result);
else {
void* data;
UInt32 size;
KprMessageGetResponseBody(self, &data, &size);
if (data && size) {
if (!FskStrCompare(target->name, "TEXT"))
*slot = xsStringBuffer(data, size);
else {
*slot = xsNewInstanceOf(xsChunkPrototype);
xsSetHostData(*slot, data);
xsSetHostDestructor(*slot , NULL);
xsSet(*slot, xsID("length"), xsInteger(size)); //@@jph
}
}
}
}
}
void KprDebugMachineEchoNode(KprDebugMachine self, int theView, int column, char flags, char* path, int line, char* name, char* data, char* value)
{
KprDebug debug = self->debug;
xsMachine* the = debug->the;
if (xsTypeOf(debug->behavior) == xsUndefinedType) goto bail;
{
xsTry {
xsVar(0) = xsAccess(debug->behavior);
xsVar(1) = xsGet(xsVar(0), xsID(self->address));
xsVar(2) = xsNewInstanceOf(xsObjectPrototype);
xsNewHostProperty(xsVar(2), xsID("column"), xsInteger(column), xsDefault, xsDontScript);
if (flags == ' ')
xsNewHostProperty(xsVar(2), xsID("state"), xsInteger(0), xsDefault, xsDontScript);
else if (flags == '+')
xsNewHostProperty(xsVar(2), xsID("state"), xsInteger(1), xsDefault, xsDontScript);
else if (flags == '-')
xsNewHostProperty(xsVar(2), xsID("state"), xsInteger(2), xsDefault, xsDontScript);
else
xsNewHostProperty(xsVar(2), xsID("state"), xsInteger(0), xsDefault, xsDontScript);
if (path)
xsNewHostProperty(xsVar(2), xsID("path"), xsString(path), xsDefault, xsDontScript);
if (line >= 0)
xsNewHostProperty(xsVar(2), xsID("line"), xsInteger(line), xsDefault, xsDontScript);
if (name)
xsNewHostProperty(xsVar(2), xsID("name"), xsString(name), xsDefault, xsDontScript);
if (data)
xsNewHostProperty(xsVar(2), xsID("data"), xsString(data), xsDefault, xsDontScript);
if (value)
xsNewHostProperty(xsVar(2), xsID("value"), xsString(value), xsDefault, xsDontScript);
if (xsFindResult(xsVar(1), xsID_push)) {
(void)xsCallFunction1(xsResult, xsVar(1), xsVar(2));
}
}
xsCatch {
}
}
bail:
return;
}
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_message_get_status(xsMachine *the)
{
KprMessage self = xsGetHostData(xsThis);
xsResult = xsInteger(self->status);
}
void KPR_message_get_timeout(xsMachine *the)
{
KprMessage self = kprGetHostData(xsThis, this, message);
xsResult = xsInteger(self->timeout);
}
void KPR_imageData_get_height(xsMachine *the)
{
FskCanvas2dImageData data = xsGetHostData(xsThis);
xsResult = xsInteger(data->height);
}
static void KPR_canvasRenderingContext2D_getStyle(xsMachine *the, xsBooleanValue stroke)
{
FskCanvas2dContext ctx;
const FskColorSourceUnion* csu;
UInt32 c, i;
FskGradientStop *stop;
xsVars(3);
ctx = xsGetHostData(xsThis);
if (stroke)
csu = (const FskColorSourceUnion *)FskCanvas2dGetStrokeStyle(ctx);
else
csu = (const FskColorSourceUnion *)FskCanvas2dGetFillStyle(ctx);
switch (csu->so.type) {
case kFskColorSourceTypeConstant:
KprSerializeColor(the, &csu->cn.color, &xsResult);
break;
case kFskColorSourceTypeLinearGradient:
xsResult = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("canvasLinearGradient")));
xsSet(xsResult, xsID("x0"), xsNumber(FskFixedToFloat(csu->lg.gradientVector[0].x)));
xsSet(xsResult, xsID("y0"), xsNumber(FskFixedToFloat(csu->lg.gradientVector[0].y)));
xsSet(xsResult, xsID("x1"), xsNumber(FskFixedToFloat(csu->lg.gradientVector[1].x)));
xsSet(xsResult, xsID("y1"), xsNumber(FskFixedToFloat(csu->lg.gradientVector[1].y)));
c = csu->lg.numStops;
stop = csu->lg.gradientStops;
goto getStops;
case kFskColorSourceTypeRadialGradient:
xsResult = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("canvasRadialGradient")));
xsSet(xsResult, xsID("x0"), xsNumber(FskFixedToFloat(csu->rg.focus.x)));
xsSet(xsResult, xsID("y0"), xsNumber(FskFixedToFloat(csu->rg.focus.y)));
xsSet(xsResult, xsID("r0"), xsNumber(0));
xsSet(xsResult, xsID("x1"), xsNumber(FskFixedToFloat(csu->rg.center.x)));
xsSet(xsResult, xsID("y1"), xsNumber(FskFixedToFloat(csu->rg.center.y)));
xsSet(xsResult, xsID("r1"), xsNumber(FskFixedToFloat(csu->rg.radius)));
c = csu->rg.numStops;
stop = csu->rg.gradientStops;
getStops:
xsVar(0) = xsNew1(xsGlobal, xsID("Array"), xsInteger(c));
for (i = 0; i < c; i++) {
xsVar(1) = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("canvasGradientStop")));
xsSet(xsVar(1), xsID("offset"), xsNumber(FskFractToFloat(stop->offset)));
KprSerializeColor(the, &stop->color, &xsVar(2));
xsSet(xsVar(1), xsID("color"), xsVar(2));
xsSetAt(xsVar(0), xsInteger(i), xsVar(1));
stop++;
}
xsSet(xsResult, xsID("stops"), xsVar(0));
break;
case kFskColorSourceTypeTexture:
xsResult = xsNewInstanceOf(xsGet(xsGet(xsGlobal, xsID("KPR")), xsID("canvasPattern")));
// @@ fskBitmapToXSBitmap(the, (FskBitmap)csu->tx.texture, false, &xsVar(0));
xsSet(xsResult, xsID("image"), xsVar(0));
c = csu->tx.spreadMethod & kFskCanvas2dPatternRepeatX;
i = csu->tx.spreadMethod & kFskCanvas2dPatternRepeatY;
if (c && i)
xsSet(xsResult, xsID("repetition"), xsString("repeat"));
else if (c)
xsSet(xsResult, xsID("repetition"), xsString("repeat-x"));
else if (i)
xsSet(xsResult, xsID("repetition"), xsString("repeat-y"));
else
xsSet(xsResult, xsID("repetition"), xsString("no-repeat"));
break;
}
}
void xs_infoset_scan(xsMachine* the)
{
int c = xsToInteger(xsArgc);
Scanner scanner;
Scanner* self;
xsVars(COUNT);
xsTry {
self = &scanner;
c_memset(self, 0, sizeof(Scanner));
if (c < 1)
xsSyntaxError("no buffer");
self->expat = XML_ParserCreate(NULL);
xsThrowIfNULL(self->expat);
XML_SetUserData(self->expat, self);
XML_SetElementHandler(self->expat, scanStartTag, scanStopTag);
XML_SetCdataSectionHandler(self->expat, scanStartCdata, scanStopCdata);
XML_SetCharacterDataHandler(self->expat, scanCharacter);
XML_SetCommentHandler(self->expat, scanComment);
XML_SetProcessingInstructionHandler(self->expat, scanProcessingInstruction);
XML_SetUnknownEncodingHandler(self->expat, scanUnknownEncoding, NULL);
XML_SetSkippedEntityHandler(self->expat, scanEntity);
self->result = 1;
self->textBuffer = c_malloc(8192);
xsThrowIfNULL(self->textBuffer);
self->textSize = 8192;
self->the = the;
xsVar(ATTRIBUTE_PROTOTYPE) = xsGet(xsThis, xsID_attribute);
xsVar(CDATA_PROTOTYPE) = xsGet(xsThis, xsID_cdata);
xsVar(COMMENT_PROTOTYPE) = xsGet(xsThis, xsID_comment);
xsVar(DOCUMENT_PROTOTYPE) = xsGet(xsThis, xsID_document);
xsVar(ELEMENT_PROTOTYPE) = xsGet(xsThis, xsID_element);
xsVar(NO_NAMESPACE) = xsString("");
xsVar(NO_PREFIX) = xsString("");
xsVar(PATH) = (c > 1) ? xsArg(1) : xsUndefined;
xsVar(PI_PROTOTYPE) = xsGet(xsThis, xsID_pi);
xsVar(XML_NAMESPACE) = xsGet(xsThis, xsID_xmlnsNamespace);
xsVar(XML_PREFIX) = xsGet(xsThis, xsID_xmlnsPrefix);
xsResult = xsNewInstanceOf(xsVar(DOCUMENT_PROTOTYPE));
xsSet(xsResult, xsID_encoding, xsString("UTF-8"));
xsSet(xsResult, xsID_version, xsString("1.0"));
xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype);
xsArrayCacheBegin(xsVar(CHILDREN));
xsSet(xsResult, xsID_children, xsVar(CHILDREN));
xsSet(xsResult, xsID_parent, xsNull);
xsSet(xsResult, xsID_xmlnsAttributes, xsNull);
if (xsIsInstanceOf(xsArg(0), xsChunkPrototype)) {
xsStringValue buffer = xsGetHostData(xsArg(0));
xsIntegerValue size = xsToInteger(xsGet(xsArg(0), xsID_length));
self->result = XML_Parse(self->expat, (const char *)buffer, size, 1);
}
else if (xsTypeOf(xsArg(0)) == xsStringType) {
xsStringValue string = xsToString(xsArg(0));
xsIntegerValue stringOffset = 0;
xsIntegerValue stringSize = c_strlen(string);
while (self->result && (stringOffset < stringSize)) {
xsIntegerValue size = stringSize - stringOffset;
xsStringValue buffer = (char *)XML_GetBuffer(self->expat, 1024);
xsThrowIfNULL(buffer);
if (size > 1024)
size = 1024;
c_memcpy(buffer, string + stringOffset, size);
self->result = XML_ParseBuffer(self->expat, size, (size < 1024) ? 1 : 0);
stringOffset += size;
string = xsToString(xsArg(0)); // @@ gc
}
}
else {
xsStreamGetter* streamGetter = xsGetHostData(xsArg(0));
while (self->result) {
xsIntegerValue i;
xsStringValue p, buffer = (char *)XML_GetBuffer(self->expat, 1024);
xsThrowIfNULL(buffer);
for (i = 0, p = buffer; i < 1024; i++, p++) {
int c = (*(streamGetter->getter))(streamGetter->stream);
if (c == C_EOF)
break;
*p = (char)c;
}
self->result = XML_ParseBuffer(self->expat, i, (i < 1024) ? 1 : 0);
if (i < 1024)
break;
}
}
xsDelete(xsResult, xsID_xmlnsAttributes);
xsDelete(xsResult, xsID_parent);
xsArrayCacheEnd(xsVar(CHILDREN));
if (!self->result) {
xsVar(LINE) = xsInteger(XML_GetCurrentLineNumber(self->expat));
xsVar(VALUE) = xsString((char*)XML_ErrorString(XML_GetErrorCode(self->expat)));
if (xsHas(xsThis, xsID_reportError))
xsCall3_noResult(xsThis, xsID_reportError, xsVar(PATH), xsVar(LINE), xsVar(VALUE));
xsThrow(xsNewInstanceOf(xsSyntaxErrorPrototype));
}
c_free(self->textBuffer);
self->textBuffer = NULL;
XML_ParserFree(self->expat);
self->expat = NULL;
}
xsCatch {
if (self->textBuffer)
c_free(self->textBuffer);
if (self->expat)
XML_ParserFree(self->expat);
}
}
void cryptThrowFSK_(xsMachine *the, int fskcode)
{
cryptThrow_(the, "kCryptSystemError", GET_XS_FNAME(), xsNew1(xsGet(xsGet(xsGlobal, xsID("Fsk")), xsID("Error")), xsID("Native"), xsInteger(fskcode)));
}
void scanStartTag(void *data, const char *tag, const char **attributes)
{
Scanner* self = data;
xsMachine* the = self->the;
const char **attribute;
char* name;
char* value;
char* colon;
scanText(data);
xsVar(LINE) = xsInteger(XML_GetCurrentLineNumber(self->expat));
xsVar(CHILD) = xsNewInstanceOf(xsVar(ELEMENT_PROTOTYPE));
xsSet(xsVar(CHILD), xsID_path, xsVar(PATH));
xsSet(xsVar(CHILD), xsID_line, xsVar(LINE));
xsSet(xsVar(CHILD), xsID_parent, xsResult);
if (!self->root) {
self->root = 1;
xsSet(xsResult, xsID_element, xsVar(CHILD));
}
xsArrayCacheItem(xsVar(CHILDREN), xsVar(CHILD));
xsResult = xsVar(CHILD);
xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype);
xsArrayCacheBegin(xsVar(CHILDREN));
attribute = attributes;
while (*attribute) {
name = (char*)*attribute;
attribute++;
value = (char*)*attribute;
attribute++;
if (c_strncmp(name, "xmlns", 5) == 0) {
colon = name + 5;
if (*colon == ':') {
*colon = 0;
xsVar(NAME) = xsString(colon + 1);
*colon = ':';
xsVar(PREFIX) = xsVar(XML_PREFIX);
}
else {
xsVar(NAME) = xsVar(XML_PREFIX);
xsVar(PREFIX) = xsUndefined;
}
xsVar(NAMESPACE) = xsVar(XML_NAMESPACE);
xsVar(VALUE) = xsString(value);
xsVar(CHILD) = xsNewInstanceOf(xsVar(ATTRIBUTE_PROTOTYPE));
xsSet(xsVar(CHILD), xsID_parent, xsResult);
xsSet(xsVar(CHILD), xsID_path, xsVar(PATH));
xsSet(xsVar(CHILD), xsID_line, xsVar(LINE));
xsSet(xsVar(CHILD), xsID_name, xsVar(NAME));
xsSet(xsVar(CHILD), xsID_namespace, xsVar(NAMESPACE));
xsSet(xsVar(CHILD), xsID_prefix, xsVar(PREFIX));
xsSet(xsVar(CHILD), xsID_value, xsVar(VALUE));
xsArrayCacheItem(xsVar(CHILDREN), xsVar(CHILD));
}
}
xsArrayCacheEnd(xsVar(CHILDREN));
xsSet(xsResult, xsID_xmlnsAttributes, xsVar(CHILDREN));
xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype);
xsArrayCacheBegin(xsVar(CHILDREN));
attribute = attributes;
while (*attribute) {
name = (char*)*attribute;
attribute++;
value = (char*)*attribute;
attribute++;
if (c_strncmp(name, "xmlns", 5) != 0) {
scanName(the, name, 0);
xsVar(VALUE) = xsString(value);
xsVar(CHILD) = xsNewInstanceOf(xsVar(ATTRIBUTE_PROTOTYPE));
xsSet(xsVar(CHILD), xsID_parent, xsResult);
xsSet(xsVar(CHILD), xsID_path, xsVar(PATH));
xsSet(xsVar(CHILD), xsID_line, xsVar(LINE));
xsSet(xsVar(CHILD), xsID_name, xsVar(NAME));
xsSet(xsVar(CHILD), xsID_namespace, xsVar(NAMESPACE));
xsSet(xsVar(CHILD), xsID_prefix, xsVar(PREFIX));
xsSet(xsVar(CHILD), xsID_value, xsVar(VALUE));
xsArrayCacheItem(xsVar(CHILDREN), xsVar(CHILD));
}
}
xsArrayCacheEnd(xsVar(CHILDREN));
xsSet(xsResult, xsID__attributes, xsVar(CHILDREN));
scanName(the, tag, 1);
xsSet(xsResult, xsID_name, xsVar(NAME));
xsSet(xsResult, xsID_namespace, xsVar(NAMESPACE));
xsSet(xsResult, xsID_prefix, xsVar(PREFIX));
xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype);
xsArrayCacheBegin(xsVar(CHILDREN));
xsSet(xsResult, xsID_children, xsVar(CHILDREN));
}
void KPR_Shell_patch(xsMachine* the)
{
xsVars(1);
xsResult = xsGet(xsGlobal, xsID("system"));
xsVar(0) = xsNewInstanceOf(xsObjectPrototype);
xsNewHostProperty(xsVar(0), xsID("arrow"), xsInteger(kFskCursorArrow), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("aliasArrow"), xsInteger(kFskCursorAliasArrow), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("copyArrow"), xsInteger(kFskCursorCopyArrow), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("wait"), xsInteger(kFskCursorWait), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("iBeam"), xsInteger(kFskCursorIBeam), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("notAllowed"), xsInteger(kFskCursorNotAllowed), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("resize"), xsInteger(kFskCursorResizeAll), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("resizeEW"), xsInteger(kFskCursorResizeLeftRight), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("resizeNS"), xsInteger(kFskCursorResizeTopBottom), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("resizeNESW"), xsInteger(kFskCursorResizeNESW), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("resizeNWSE"), xsInteger(kFskCursorResizeNWSE), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("link"), xsInteger(kFskCursorLink), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("resizeColumn"), xsInteger(kFskCursorResizeColumn), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(0), xsID("resizeRow"), xsInteger(kFskCursorResizeRow), xsDefault, xsDontScript);
xsNewHostProperty(xsResult, xsID("cursors"), xsVar(0), xsDefault, xsDontScript);
}
void KPR_message_get_error(xsMachine *the)
{
KprMessage self = xsGetHostData(xsThis);
xsResult = xsInteger(self->error);
}
static FskErr
makeSSLRootVM(const char *calistpath)
{
#ifdef KPR_CONFIG
FskErr err = kFskErrNone;
xsBeginHost(gShell->root);
xsTry {
xsCall1_noResult(xsGet(xsGlobal, xsID("FskSSL")), xsID("loadRootCerts"), xsString((xsStringValue)calistpath));
} xsCatch {
err = kFskErrOperationFailed;
}
xsEndHost(gShell->root);
return err;
#else
char *rootPath, *xsbPath, *xsbName;
xsGrammar *grammar;
FskErr err;
if ((err = FskMemPtrNewClear(sizeof(FskECMAScriptRecord), &gSSLVM)) != kFskErrNone)
return err;
#if FSK_EMBED
FskExtensionsEmbedLoad(SSL_VMNAME);
FskExtensionsEmbedGrammar(SSL_VMNAME, &xsbName, &grammar);
#else
xsbName = "FskCore.xsb";
grammar = &FskCoreGrammar;
#endif
rootPath = FskEnvironmentDoApply(FskStrDoCopy("[applicationPath]"));
xsbPath = FskStrDoCat(rootPath, xsbName);
FskMemPtrDispose(rootPath);
grammar->name = (xsStringValue)SSL_VMNAME;
if ((err = loadGrammar(xsbPath, grammar)) == kFskErrNone) {
if ((gSSLVM->the = xsNewMachine(&anAllocation, grammar, gSSLVM)) == NULL)
err = kFskErrMemFull;
FskMemPtrDispose(grammar->symbols);
FskMemPtrDispose(grammar->code);
}
FskMemPtrDispose(xsbPath);
BAIL_IF_ERR(err);
xsBeginHost(gSSLVM->the);
xsTry {
#if !FSK_EMBED
/* load Crypt and FskSSL extensions which are only needed for Fsk SSL */
xsCall3_noResult(xsGet(xsGlobal, xsID("System")), xsID("loadExtension"), xsString("Crypt"), xsString("[applicationPath]"), xsInteger(0));
xsCall3_noResult(xsGet(xsGlobal, xsID("System")), xsID("loadExtension"), xsString("FskSSL"), xsString("[applicationPath]"), xsInteger(1));
#endif
xsCall1_noResult(xsGet(xsGlobal, xsID("FskSSL")), xsID("loadRootCerts"), xsString((xsStringValue)calistpath));
} xsCatch {
err = kFskErrOperationFailed;
}
xsEndHost(gSSLVM->the);
if (err == kFskErrNone)
xsShareMachine(gSSLVM->the);
bail:
if (err != kFskErrNone)
disposeSSLRootVM();
return err;
#endif
}
void Zeroconf_advertisement_get_port(xsMachine *the)
{
KprZeroconfAdvertisement self = xsGetHostData(xsThis);
xsResult = xsInteger(self->port);
}
void
xs_x509_decodeSubjectKeyId(xsMachine *the)
{
UInt32 sz = xsToInteger(xsGet(xsArg(0), xsID("length")));
unsigned char *p = xsGetHostData(xsArg(0)), *endp = p + sz, *endTBS, *endEXT, *extnID, *spki, *spk;
int l, extnIDLen, spkLen;
static UInt8 id_ce_ski[] = {2 * 40 + 5, 29, 14}; /* [2, 5, 29, 14] */
#define getTag() (p < endp ? (int)*p++ : -1)
#define getBerLen() _getBerLen(&p, endp)
#define nextTag() (getTag(), l = getBerLen(), p += l)
if (getTag() != 0x30)
return;
if ((l = getBerLen()) < 0)
return;
if (p + l > endp)
return;
/* TBSCertficate */
if (getTag() != 0x30)
return;
if ((l = getBerLen()) < 0)
return;
if ((endTBS = p + l) > endp)
return;
if (*p & 0x80) {
/* EXPLICT Version */
p++;
nextTag();
}
nextTag(); /* serialNumber */
nextTag(); /* signature */
nextTag(); /* issuer */
nextTag(); /* validity */
nextTag(); /* subject */
spki = p; /* subjectPublicKeyInfo */
nextTag();
/* OPTIONAL */
while (p < endTBS) {
int tag = getTag();
if ((l = getBerLen()) < 0)
return;
switch (tag & 0x1f) {
case 1: /* issuerUniqueID */
case 2: /* subjectUniqueID */
p += l;
continue; /* goto the next tag */
case 3: /* extensions */
break; /* fall thru */
default:
return;
}
/* must be a SEQUENCE of [1..MAX] */
if (getTag() != 0x30)
return;
if ((l = getBerLen()) < 0)
return;
endEXT = p + l;
while (p < endEXT) {
/* must be a SEQUENCE of {extnID, critical, extnValue} */
if (getTag() != 0x30)
return;
if ((l = getBerLen()) < 0)
return;
/* extnID: OBJECT ID */
if (getTag() != 0x06)
return;
if ((extnIDLen = getBerLen()) < 0)
return;
extnID = p;
p += extnIDLen;
/* critical: BOOLEAN */
if (*p == 0x01)
nextTag();
/* extnValue: OCTET STRING */
if (getTag() != 0x04)
return;
if ((l = getBerLen()) < 0)
return;
if (extnIDLen == sizeof(id_ce_ski) && FskMemCompare(extnID, id_ce_ski, extnIDLen) == 0) {
/* SKI: OCTET STRING */
if (getTag() != 0x04)
return;
l = getBerLen();
xsResult = xsNew1(xsGlobal, xsID("Chunk"), xsInteger(l));
FskMemCopy(xsGetHostData(xsResult), p, l);
return;
}
p += l;
}
}
{
/*
* Couldn't find Subject Key Identifier. Make up the ID from the Subject Public Key
*/
struct sha1 sha1;
p = spki;
if (getTag() != 0x30)
return; /* should be a SEQUENCE */
l = getBerLen();
/* skip AlgorithmIdentifier */
nextTag();
if (getTag() != 0x03)
return; /* should be a BIT STRING */
spkLen = getBerLen();
spk = p;
xsResult = xsNew1(xsGlobal, xsID("Chunk"), xsInteger(SHA1_DGSTSIZE));
sha1_create(&sha1);
sha1_update(&sha1, spk, spkLen);
sha1_fin(&sha1, xsGetHostData(xsResult));
}
}
void KPR_mqttclient_publish(xsMachine* the)
{
KPR_MQTTClientRecord *self = xsGetHostData(xsThis);
FskErr err = kFskErrNone;
xsIntegerValue c = xsToInteger(xsArgc);
char *topic = NULL;
void *payload = NULL;
UInt32 payloadLength = 0;
UInt8 qos = 0;
Boolean retain = false, hasPayload = false, hasQos = false, hasRetain = false;
UInt16 token;
/*
Case 1.
topic, string_or_chunk, qos, retain
Case 2
topic, { payload: string_or_chunk}, qos, retain
Case 3
topic, { payload: string_or_chunk, qos: 0, retain: true }
*/
if (c < 1) goto invalidParams;
topic = xsToString(xsArg(0));
if (c >= 2) {
if (isChunk(xsArg(1))) {
payload = xsGetHostData(xsArg(1));
payloadLength = xsToInteger(xsGet(xsArg(1), xsID_length));
} else if (isObject(xsArg(1))) {
xsVars(1);
xsEnterSandbox();
{
hasPayload = xsHas(xsArg(1), xsID("data"));
if (hasPayload) xsVar(0) = the->scratch;
hasQos = xsHas(xsArg(1), xsID("qos"));
if (hasQos) qos = xsToInteger(the->scratch);
hasRetain = xsHas(xsArg(1), xsID("retain"));
if (hasRetain) retain = xsToInteger(the->scratch);
}
xsLeaveSandbox();
if (hasPayload) {
if (isChunk(xsVar(0))) {
payload = xsGetHostData(xsVar(0));
payloadLength = xsToInteger(xsGet(xsVar(0), xsID_length));
} else {
payload = xsToString(xsVar(0));
payloadLength = FskStrLen(payload);
}
}
} else {
payload = xsToString(xsArg(1));
payloadLength = FskStrLen(payload);
}
}
if (c >= 3 && !hasQos) {
qos = xsToInteger(xsArg(2));
}
if (c >= 4 && !hasRetain) {
retain = xsToBoolean(xsArg(3));
}
if (!KprMQTTIsValidTopic(topic, false)) goto badParam;
if (qos > 2) goto badParam;
bailIfError(KprMQTTClientPublish(self->client, topic, payload, payloadLength, qos, retain, &token));
xsResult = xsInteger(token);
goto bail;
invalidParams:
err = kFskErrInvalidParameter;
goto bail;
badParam:
err = kFskErrBadData;
goto bail;
bail:
xsThrowIfFskErr(err);
}
