FskErr
FskSSLHandshake(void *a, FskNetSocketCreatedCallback callback, void *refCon, Boolean initiate)
{
FskSSL *fssl = a;
FskErr err = kFskErrNone;
fssl->socketCallback = callback;
fssl->callbackData = refCon;
xsBeginHost(fssl->vm->the);
xsTry {
xsVars(1);
/* set session._hostData = ssl, just for callback */
xsVar(0) = xsNewHostObject(NULL);
xsSetHostData(xsVar(0), fssl);
xsSet(fssl->ssl, xsID("_hostData"), xsVar(0));
xsVar(0) = xsNewHostFunction(xs_handshake_finished_callback, 2);
xsSet(fssl->ssl, xsID("_hostCallback"), xsVar(0));
xsCall3_noResult(fssl->ssl, xsID("handshake"), fssl->socket, xsVar(0), initiate ? xsTrue : xsFalse);
} xsCatch {
if (xsHas(xsException, xsID("code")))
err = xsToInteger(xsGet(xsException, xsID("code")));
if (err == kFskErrNone)
err = kFskErrOperationFailed;
}
xsEndHost(fssl->vm->the);
return err;
}
void scanEntity(void *data, const XML_Char *entityName, int is_parameter_entity)
{
Scanner* self = data;
xsMachine* the = self->the;
Entity* entity = (Entity*)bsearch(entityName, gxEntities, mxEntityCount, sizeof(Entity), compareEntities);
if (entity)
scanCharacter(data, entity->value, entity->valueLength);
else {
xsVar(LINE) = xsInteger(XML_GetCurrentLineNumber(self->expat));
xsVar(VALUE) = xsString((xsStringValue)entityName);
xsCall3_noResult(xsThis, xsID_reportError, xsVar(PATH), xsVar(LINE), xsVar(VALUE));
scanCharacter(data, entityName, c_strlen(entityName));
}
}
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 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);
}
}
