void
xs_mod_init(xsMachine *the)
{
mod_t *mod;
UInt32 options = xsToInteger(xsArgc) > 0 && xsTypeOf(xsArg(0)) == xsIntegerType ? xsToInteger(xsArg(0)): 0;
FskErr ferr;
if ((ferr = FskMemPtrNew(sizeof(mod_t), (FskMemPtr *)&mod)) != kFskErrNone)
cryptThrowFSK(ferr);
if ((ferr = FskMemPtrNew(sizeof(bn_mod_t), (FskMemPtr *)&mod->mod_data)) != kFskErrNone) {
FskMemPtrDispose(mod);
cryptThrowFSK(ferr);
}
mod->_mod_code = &modFuncs;
xsResult = xsGet(xsThis, xsID("z")); /* must exist */
if (!xsIsInstanceOf(xsResult, xsGet(xsGet(xsGlobal, xsID("Arith")), xsID("z"))) || (mod->z = xsGetHostData(xsResult)) == NULL)
cryptThrow("kCryptTypeError");
xsResult = xsGet(xsThis, xsID("m")); /* must exist */
if (!xsIsInstanceOf(xsResult, mod->z->z_protoInteger) || (mod->m = xsGetHostData(xsResult)) == NULL)
nanError();
bn_mod_init(mod->mod_data, mod->z->z_data, mod->m->cint_data, options);
xsSetHostData(xsThis, mod);
}
void KPR_mqttclient_subscribe(xsMachine* the)
{
KPR_MQTTClientRecord *self = xsGetHostData(xsThis);
FskErr err = kFskErrNone;
xsIntegerValue c = xsToInteger(xsArgc);
char **topics = NULL;
UInt8 *qoss = NULL;
int i, count;
UInt16 token;
if (c == 0 || (c % 2) != 0) xsThrowIfFskErr(kFskErrParameterError);
count = c / 2;
bailIfError(FskMemPtrNew(sizeof(char*) * count, &topics));
bailIfError(FskMemPtrNew(sizeof(UInt8*) * count, &qoss));
for (i = 0; i < count; i++) {
topics[i] = xsToString(xsArg(i * 2));
qoss[i] = xsToInteger(xsArg(i * 2 + 1));
}
bailIfError(KprMQTTClientSubscribeTopics(self->client, topics, qoss, count, &token));
xsResult = xsInteger(token);
bail:
FskMemPtrDispose(topics);
FskMemPtrDispose(qoss);
xsThrowIfFskErr(err);
}
FskErr KprURLMerge(char* base, char* reference, char** result)
{
FskErr err = kFskErrNone;
KprURLPartsRecord parts;
KprURLPartsRecord baseParts;
char* path = NULL;
UInt32 length;
KprURLSplit(reference, &parts);
if (!parts.scheme) {
KprURLSplit(base, &baseParts);
parts.scheme = baseParts.scheme;
parts.schemeLength = baseParts.schemeLength;
if (!parts.authority) {
parts.authority = baseParts.authority;
parts.authorityLength = baseParts.authorityLength;
if (!parts.pathLength) {
if (baseParts.authority && !baseParts.pathLength) {
bailIfError(FskMemPtrNew(1, &path));
FskMemMove(path, "/", 1);
parts.path = path;
parts.pathLength = 1;
}
else {
parts.path = baseParts.path;
parts.pathLength = baseParts.pathLength;
}
if (!parts.query) {
parts.query = baseParts.query;
parts.queryLength = baseParts.queryLength;
}
}
else if (*parts.path != '/') {
if (baseParts.authority && !baseParts.pathLength) {
bailIfError(FskMemPtrNew(1 + parts.pathLength, &path));
FskMemMove(path, "/", 1);
FskMemMove(path + 1, parts.path, parts.pathLength);
parts.path = path;
parts.pathLength++;
}
else if (baseParts.name) {
length = baseParts.name - baseParts.path;
bailIfError(FskMemPtrNew(length + parts.pathLength, &path));
FskMemMove(path, baseParts.path, length);
FskMemMove(path + length, parts.path, parts.pathLength);
parts.path = path;
parts.pathLength += length;
}
}
}
}
bailIfError(KprURLJoin(&parts, result));
bail:
FskMemPtrDispose(path);
return err;
}
static FskErr httpServerListenerStart(FskHTTPServerListener listener, FskSocket skt) {
FskErr err = kFskErrNone;
FskHTTPServerRequest request;
if (listener->http->stopped) {
FskInstrumentedItemSendMessage(listener->http, kFskHTTPInstrMsgConnectionRefusedStopped, listener);
listener->http->stats.connectionsRefused++;
FskNetSocketClose(skt);
goto bail;
}
err = FskMemPtrNewClear(sizeof(FskHTTPServerRequestRecord), (FskMemPtr*)&request);
BAIL_IF_ERR(err);
sFskHTTPServerRequestUpUse(request);
request->http = listener->http;
request->skt = skt;
FskNetSocketGetRemoteAddress(skt, (UInt32 *)&request->requesterAddress, &request->requesterPort);
FskNetSocketMakeNonblocking(request->skt);
err = FskHeaderStructNew(&request->requestHeaders);
BAIL_IF_ERR(err);
err = FskHeaderStructNew(&request->responseHeaders);
BAIL_IF_ERR(err);
request->in.bufferSize = request->http->defaultBufferSize;
request->out.bufferSize = request->http->defaultBufferSize;
err = FskMemPtrNew(request->in.bufferSize, (FskMemPtr*)&request->in.buf);
BAIL_IF_ERR(err);
err = FskMemPtrNew(request->out.bufferSize, (FskMemPtr*)&request->out.buf);
BAIL_IF_ERR(err);
FskListAppend((FskList*)&request->http->activeRequests, request);
FskTimeCallbackNew(&request->cycleCallback);
FskTimeCallbackNew(&request->keepAliveKillCallback);
listener->http->stats.connectionsMade++;
request->state = kHTTPNewSession;
FskInstrumentedItemNew(request, NULL, &gFskHTTPServerRequestTypeInstrumentation);
FskInstrumentedItemSetOwner(request, request->http);
FskTimeCallbackScheduleNextRun(request->cycleCallback, httpServerTimeCycle, request);
doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionConnectionInitialized, request->refCon);
FskTimeCallbackNew(&request->timer);
FskTimeCallbackScheduleFuture(request->timer, 1, 0, KprHTTPServerTimerCallback, request);
bail:
if (err)
FskHTTPServerRequestDispose(request);
return err;
}
static FskErr sFskNetInterfaceEnumerate(FskNetInterfaceRecord **interfaceList)
{
FskErr err;
KplNetInterfaceRecord *kplInterfaceList;
*interfaceList = NULL;
err = KplNetInterfaceEnumerate(&kplInterfaceList);
BAIL_IF_ERR(err);
while (kplInterfaceList) {
FskNetInterfaceRecord *nir;
KplNetInterfaceRecord *next = kplInterfaceList->next;
err = FskMemPtrNew(sizeof(FskNetInterfaceRecord), (FskMemPtr*)&nir);
BAIL_IF_ERR(err);
nir->name = FskStrDoCopy(kplInterfaceList->name);
nir->ip = kplInterfaceList->ip;
FskMemMove(nir->MAC, kplInterfaceList->MAC, sizeof(nir->MAC));
nir->status = kplInterfaceList->status;
nir->netmask = kplInterfaceList->netmask;
FskListAppend((FskList*)interfaceList, nir);
FskMemPtrDispose(kplInterfaceList->name);
FskMemPtrDispose(kplInterfaceList);
kplInterfaceList = next;
}
bail:
return err;
}
static FskErr KprWebSocketEndpointStartClosingHandshake(KprWebSocketEndpoint self, UInt16 code, char *reason)
{
FskErr err = kFskErrNone;
char *payload = NULL;
UInt32 length = sizeof(UInt16);
self->state = kKprWebSocketStateClosing;
CALLBACK(closingCallback)(self, self->closeCode, self->closeReason, self->cleanClose, self->refcon);
length += FskStrLen(reason);
bailIfError(FskMemPtrNew(length, &payload));
*((UInt16 *) payload) = FskEndianU16_NtoB(code);
FskMemCopy(&payload[2], reason, length - sizeof(UInt16));
bailIfError(KprWebSocketEndpointSendRawFrame(self, kKprWebSocketOpcodeClose, payload, length));
self->closeWasSent = true;
bail:
if (payload) FskMemPtrDispose(payload);
if (err || (self->closeWasSent && self->closeWasReceived)) {
self->cleanClose = (err == kFskErrNone);
KprWebSocketEndpointDisconnect(self);
}
return err;
}
VOID __stdcall KprNetworkInterfaceCallback(PVOID context, PMIB_IPINTERFACE_ROW interfaceRow, MIB_NOTIFICATION_TYPE notificationType)
{
int ip;
FskErr err = kFskErrNone;
IP_ADAPTER_INFO *adapters = NULL;
DWORD result;
DWORD size = 15000;
IP_ADAPTER_INFO *adapter;
IP_ADDR_STRING *address;
for (ip = 0; ip < 3; ip++) {
err = FskMemPtrNew(size, &adapters);
result = GetAdaptersInfo(adapters, &size);
if (ERROR_BUFFER_OVERFLOW == result) {
FskMemPtrDispose(adapters);
adapters = NULL;
}
else
break;
}
if (ERROR_SUCCESS == result) {
for (adapter = adapters ; NULL != adapter ; adapter = adapter->Next) {
for (address = &adapter->IpAddressList; address; address = address->Next) {
if (FskStrLen(address->IpAddress.String) == 0)
continue;
FskNetStringToIPandPort(address->IpAddress.String, &ip, NULL);
if (0x7f000001 != ip)
KprNetworkInterfaceMark(ip, adapter->AdapterName);
}
}
KprNetworkInterfaceSweep();
}
FskMemPtrDispose(adapters);
}
static FskErr KprWebSocketServerRequestNew(KprWebSocketServerRequest *it, KprWebSocketServer server, FskSocket skt) {
FskErr err = kFskErrNone;
KprWebSocketServerRequest request = NULL;
bailIfError(FskMemPtrNewClear(sizeof(KprWebSocketServerRequestRecord), &request));
request->server = server;
request->skt = skt;
skt = NULL;
FskNetSocketGetRemoteAddress(request->skt, (UInt32 *)&request->requesterAddress, &request->requesterPort);
FskNetSocketMakeNonblocking(request->skt);
bailIfError(FskHeaderStructNew(&request->requestHeaders));
bailIfError(FskHeaderStructNew(&request->responseHeaders));
request->out.size = 512;
bailIfError(FskMemPtrNew(request->out.size, &request->out.buffer));
FskThreadAddDataHandler(&request->dataHandler, (FskThreadDataSource)request->skt, (FskThreadDataReadyCallback)KprWebSocketServerRequestDoRead, true, false, request);
// request->state = kHTTPNewSession;
*it = request;
bail:
if (err) {
KprWebSocketServerRequestDispose(request);
FskNetSocketClose(skt);
}
return err;
}
FskErr KprQuerySerialize(FskAssociativeArray array, char** it)
{
FskErr err = kFskErrNone;
FskAssociativeArrayIterator iterate = FskAssociativeArrayIteratorNew(array);
SInt32 length = 0;
char* p;
while (iterate) {
if (length)
length++;
length += FskStrLen(iterate->name);
length++;
length += FskStrLen(iterate->value);
}
length++;
FskAssociativeArrayIteratorDispose(iterate);
iterate = NULL;
bailIfError(FskMemPtrNew(length, it));
iterate = FskAssociativeArrayIteratorNew(array);
p = *it;
*p = 0;
while (iterate) {
if (*p)
*p++ = '&';
FskStrCopy(p, iterate->name);
p += FskStrLen(iterate->name);
*p++ = '=';
FskStrCopy(p, iterate->value);
p += FskStrLen(iterate->value);
}
*p = 0;
FskAssociativeArrayIteratorDispose(iterate);
bail:
return err;
}
FskErr KprAuthorityReverse(char* id, char** di)
{
FskErr err = kFskErrNone;
char *p, *q;
SInt32 c = FskStrLen(id), i;
bailIfError(FskMemPtrNew(c + 1, di));
p = id + c;
q = *di;
i = 0;
while (c) {
c--;
p--;
if (*p == '.') {
p++;
FskMemCopy(q, p, i);
q += i;
*q++ = '.';
p--;
i = 0;
}
else
i++;
}
FskMemCopy(q, p, i);
q += i;
*q = 0;
bail:
return err;
}
// ------------------------------------------------------------------------
void FskAssociativeArrayElementSet(FskAssociativeArray array, const char *name, const void *value, UInt32 valueSize, SInt32 valueType)
{
FskAssociativeArrayNameList list;
SInt32 nameLen = FskStrLen(name) + 1;
if (kFskStringType == valueType)
valueSize = FskStrLen((const char *)value) + 1;
else if (kFskBlobType == valueType)
;
else
valueSize = 0;
FskAssociativeArrayElementDispose(array, name);
if (kFskErrNone == FskMemPtrNew(sizeof(FskAssociativeArrayNameListRec) + nameLen + valueSize, &list)) {
unsigned char *d = list->data;
list->name = (char *)d;
FskMemMove(d, name, nameLen);
d += nameLen;
list->valueType = valueType;
list->valueSize = valueSize;
list->next = NULL;
if ((kFskStringType == valueType) || (kFskBlobType == valueType)) {
FskMemMove(d, value, valueSize);
list->value = (char *)d;
}
else
list->value = (char *)value;
FskListPrepend((FskList*)(void*)&array->arrayHead, (FskListElement)list);
}
}
FskErr KplFileGetPathInfo(const char *rootpath, const char *filepath, KplFileInfo *itemInfo) {
int err;
STATTYPE statbuf;
char *fullpath;
err = FskMemPtrNew(FskStrLen(rootpath) + FskStrLen(filepath) + 2, (FskMemPtr *)&fullpath);
if (err) return err;
FskStrCopy(fullpath, rootpath);
FskStrCat(fullpath, "/");
FskStrCat(fullpath, filepath);
err = STAT(fullpath, &statbuf);
if (err == -1) {
err = errnoToFskErr(errno);
goto bail;
}
GetFileInfoFromStat(&statbuf, itemInfo);
bail:
FskMemPtrDispose(fullpath);
return err;
}
static FskErr KprWebSocketEndpointReadFrameMessage(KprSocketReader reader, KprWebSocketEndpoint self)
{
FskErr err = kFskErrNone;
UInt32 length = self->read.length;
if (length > 0) {
if (self->read.message == NULL) {
err = FskMemPtrNew(length, &self->read.message);
if (err != kFskErrNone) return err;
}
err = KprSocketReaderReadBytes(reader, self->read.message, length);
if (err != kFskErrNone) return err;
if (self->read.mask) {
KprWebSocketMask((UInt8 *) self->read.message, length, self->read.maskData);
}
}
KprSocketReaderSetState(reader, kKprWebSocketEndpoint_onFrameOpcode);
if ((self->needMaskedFrame && !self->read.mask)
|| (self->needNonMaskedFrame && self->read.mask)) {
self->ignoreFurtherFrame = true;
bailIfError(kFskErrBadData);
}
err = KprWebSocketEndpointHandleFrame(self, self->read.opcode, self->read.message, length);
bail:
FskMemPtrDisposeAt(&self->read.message);
return err;
}
static FskErr
FillJaggyPolygonContours(
UInt32 nContours,
const UInt32 *nPts,
const FskFixedPoint2D *pts,
const FskColorSource *colorSource,
SInt32 fillRule,
const FskFixedMatrix3x2 *M,
FskConstRectangle clipRect,
FskBitmap dstBM
)
{
FskRectangleRecord dstRect;
LinkedEdge edges[MAX_EDGES], *pEdges = edges; /* Small polygons use auto edges, large ones need to be alloc'ed */
UInt32 numEdges, totPts;
FskSpan span;
FskErr err = kFskErrNone;
SInt32 n;
const UInt32 *np;
LinkedEdge *pe;
static FskInitSpanProc initProcs[] = {
FskInitSolidColorSpan,
FskInitLinearGradientSpan,
FskInitRadialGradientSpan,
FskInitTextureSpan,
NULL /* Procedure span is not yet implemented */
};
FskInitSpanProc initSpan;
if (clipRect == NULL) dstRect = dstBM->bounds;
else if (!FskRectangleIntersect(&dstBM->bounds, clipRect, &dstRect)) return kFskErrNothingRendered;
for (n = nContours, np = nPts, totPts = 0; n--; )
totPts += *np++;
FskInitSpan(&span, dstBM, sizeof(LinkedEdge)); /* Generic span init */
initSpan = initProcs[((n = colorSource->type) <= kFskColorSourceTypeMax) ? n : 0];
if ((err = (*initSpan)(&span, dstBM, M, 0, colorSource)) != kFskErrNone) /* Specialized span init - this may bump up the edge size */
return err;
span.edgeBytes = (span.edgeBytes + 3) & ~3; /* Ceil up to multiple of 4 bytes */
if ( CANT_USE_AUTO_EDGES(totPts) /* Either small enough for auto storage ... */
&& (err = (FskMemPtrNew(totPts * CLIP_MULTIPLIER * sizeof(LinkedEdge), (FskMemPtr*)(void*)(&pEdges))) != kFskErrNone) /* ... or we can allocate memory */
)
return err; /* Polygon is too big to render */
for (numEdges = 0, pe = pEdges; nContours--; pts += *nPts++, numEdges += n, pe += n)
BAIL_IF_NEGATIVE(n = TransformClipAndMakeEdges(*nPts, pts, M, &dstRect, &span, pe), err, kFskErrMemFull);
BAIL_IF_FALSE(numEdges >= 2, err, kFskErrNothingRendered);
err = ScanConvertLinkedEdges(numEdges, pEdges, fillRule, &span);
bail:
if (pEdges != edges)
FskMemPtrDispose(pEdges); /* Deallocate big polygon edges */
if ((span.disposeSpanData != NULL) && (span.spanData != NULL))
span.disposeSpanData(span.spanData);
return err;
}
FskErr loadGrammar(const char *xsbPath, xsGrammar *theGrammar)
{
FskErr err;
FskFile fref = NULL;
UInt32 atom[2];
err = FskFileOpen(xsbPath, kFskFilePermissionReadOnly, &fref);
if (err) goto bail;
err = FskFileRead(fref, sizeof(atom), atom, NULL);
if (err) goto bail;
atom[0] = FskEndianU32_BtoN(atom[0]);
atom[1] = FskEndianU32_BtoN(atom[1]);
if (atom[1] == 'XS11') {
SInt32 totalSize = (SInt32)atom[0] - sizeof(atom);
while (totalSize > 0) {
UInt32 blockSize;
char *block;
err = FskFileRead(fref, sizeof(atom), atom, NULL);
if (err) break;
atom[0] = FskEndianU32_BtoN(atom[0]);
atom[1] = FskEndianU32_BtoN(atom[1]);
totalSize -= atom[0];
blockSize = atom[0] - sizeof(atom);
err = FskMemPtrNew(blockSize, &block);
if (err) break;
err = FskFileRead(fref, blockSize, block, NULL);
if (err) break;
switch (atom[1]) {
case 'SYMB':
theGrammar->symbols = block;
theGrammar->symbolsSize = blockSize;
break;
case 'CODE':
theGrammar->code = block;
theGrammar->codeSize = blockSize;
break;
default:
FskMemPtrDispose(block);
err = kFskErrBadData;
break;
}
}
}
else
err = kFskErrBadData;
bail:
FskFileClose(fref);
return err;
}
FskErr KprPathToURL(char* path, char** result)
{
FskErr err = kFskErrNone;
unsigned char* src;
SInt32 size;
unsigned char c;
unsigned char* dst;
src = (unsigned char*)path;
#if TARGET_OS_WIN32
if ((path[0] == '/') && (path[1] == '/'))
size = 5;
else if (path[1] == ':')
size = 8;
else
return kFskErrInvalidParameter;
#else
if (path[0] == '/')
size = 7;
else
return kFskErrInvalidParameter;
#endif
while ((c = *src++)) {
if ((c < 128) && (gxURIReservedAndUnescapedSet[(int)c]))
size += 1;
else
size += 3;
}
size += 1;
bailIfError(FskMemPtrNew(size, result));
src = (unsigned char*)path;
dst = (unsigned char*)*result;
#if TARGET_OS_WIN32
if ((path[0] == '/') && (path[1] == '/')) {
FskStrCopy(*result, "file:");
dst += 5;
}
else if (path[1] == ':') {
FskStrCopy(*result, "file:///");
dst += 8;
}
#else
FskStrCopy(*result, "file://");
dst += 7;
#endif
while ((c = *src++)) {
if ((c < 128) && (gxURIReservedAndUnescapedSet[(int)c]))
*dst++ = c;
else {
*dst++ = '%';
*dst++ = gxURIHexa[c >> 4];
*dst++ = gxURIHexa[c & 15];
}
}
*dst = 0;
bail:
return err;
}
static char *
kcl_z_init(xsMachine *the, z_t **rp)
{
bn_context_t *ctx;
FskErr ferr;
if ((ferr = FskMemPtrNew(sizeof(z_t), (FskMemPtr *)rp)) != kFskErrNone)
return fskErrorToString(ferr);
if ((ferr = FskMemPtrNew(sizeof(bn_context_t), (FskMemPtr *)&ctx)) != kFskErrNone) {
FskMemPtrDispose(*rp);
return fskErrorToString(ferr);
}
bn_init_context(the, ctx);
(*rp)->_z_code = &zFuncs;
(*rp)->z_data = ctx;
return(NULL);
}
void fxLoadModuleJSB(txMachine* the, txString path, txID moduleID)
{
FskErr err = kFskErrNone;
txScript* script = NULL;
FskFile fref = NULL;
Atom atom;
bailIfError(FskMemPtrNewClear(sizeof(txScript), &script));
bailIfError(FskFileOpen(path, kFskFilePermissionReadOnly, &fref));
bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));
bailAssert(atom.atomType == XS_ATOM_BINARY);
bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));
bailAssert(atom.atomType == XS_ATOM_VERSION);
bailIfError(FskFileRead(fref, sizeof(script->version), script->version, NULL));
bailAssert(script->version[0] == XS_MAJOR_VERSION);
bailAssert(script->version[1] == XS_MINOR_VERSION);
bailAssert(script->version[2] == XS_PATCH_VERSION);
bailAssert(script->version[3] != -1);
bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));
bailAssert(atom.atomType == XS_ATOM_SYMBOLS);
script->symbolsSize = atom.atomSize - sizeof(atom);
bailIfError(FskMemPtrNew(script->symbolsSize, &script->symbolsBuffer));
bailIfError(FskFileRead(fref, script->symbolsSize, script->symbolsBuffer, NULL));
bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));
bailAssert(atom.atomType == XS_ATOM_CODE);
script->codeSize = atom.atomSize - sizeof(atom);
bailIfError(FskMemPtrNew(script->codeSize, &script->codeBuffer));
bailIfError(FskFileRead(fref, script->codeSize, script->codeBuffer, NULL));
bail:
if (fref)
FskFileClose(fref);
if (err) {
if (script) {
fxDeleteScript(script);
script = NULL;
}
}
fxResolveModule(the, moduleID, script, NULL, NULL);
}
static char *
kcl_cint_init(cint_t **rp)
{
FskErr ferr;
if ((ferr = FskMemPtrNew(sizeof(cint_t), (FskMemPtr *)rp)) != kFskErrNone)
return fskErrorToString(ferr);
(*rp)->cint_data = NULL; /* this = NaN */
(*rp)->_cint_code = &cintFuncs;
return(NULL);
}
void fxLink(txMachine* the, xsGrammar* theGrammar)
{
txScript* script = NULL;
FskErr err = kFskErrNone;
err = FskMemPtrNewClear(sizeof(txScript), &script);
if (err) goto bail;
err = FskMemPtrNew(theGrammar->symbolsSize, &script->symbolsBuffer);
if (err) goto bail;
err = FskMemPtrNew(theGrammar->codeSize, &script->codeBuffer);
if (err) goto bail;
FskMemCopy(script->symbolsBuffer, theGrammar->symbols, theGrammar->symbolsSize);
script->symbolsSize = theGrammar->symbolsSize;
FskMemCopy(script->codeBuffer, theGrammar->code, theGrammar->codeSize);
script->codeSize = theGrammar->codeSize;
script->callback = theGrammar->callback;
fxRunScript(the, script, C_NULL, C_NULL, C_NULL, C_NULL);
script = C_NULL;
bail:
fxDeleteScript(script);
return;
}
FskErr KprMessageSetResponseBody(KprMessage self, void* data, UInt32 size)
{
FskErr err = kFskErrNone;
FskMemPtrDisposeAt(&self->response.body);
self->response.size = 0;
if (data && size) {
bailIfError(FskMemPtrNew(size, &self->response.body));
FskMemCopy(self->response.body, data, size);
self->response.size = size;
}
bail:
return err;
}
static char *
kcl_int_new(cint_t *ai, bn_size size)
{
bn_t *bn;
FskErr ferr;
if ((ferr = FskMemPtrNew(sizeof(bn_t) + ((size - 1) * sizeof(bn_word)), (FskMemPtr *)&bn)) != kFskErrNone)
return fskErrorToString(ferr);
bn->sign = 0;
bn->size = size;
ai->cint_data = bn;
return NULL;
}
/*
* Volume iterator
*/
#if __unused__ /* remain here just for reference. Should work on 10.7 or later */
static Boolean getVolumeProperty(const char *path, CFStringRef key, void *value)
{
FskErr err;
char *url;
CFURLRef urlRef;
if ((err = FskMemPtrNew(sizeof("file://") + FskStrLen(path), (FskMemPtr *)&url)) != kFskErrNone)
return false;
FskStrCopy(url, "file://");
FskStrCat(url, path);
urlRef = CFURLCreateWithBytes(NULL, (UInt8 *)url, FskStrLen(url), kCFStringEncodingUTF8, NULL);
FskMemPtrDispose(url);
return CFURLCopyResourcePropertyForKey(urlRef, key, value, NULL);
}
static FskErr KprWebSocketEndpointHandleTextMessage(KprWebSocketEndpoint self, void *message, UInt32 length)
{
FskErr err = kFskErrNone;
char *text = NULL;
bailIfError(FskMemPtrNew(length + 1, &text));
FskMemCopy(text, message, length);
text[length] = 0;
CALLBACK(textCallback)(self, text, self->refcon);
bail:
if (text) FskMemPtrDispose(text);
return err;
}
FskErr KprMessageSetRequestCertificate(KprMessage self, void* certificate, UInt32 size, char *policies)
{
FskErr err = kFskErrNone;
FskMemPtrDisposeAt(&self->request.certificate);
FskMemPtrDisposeAt(&self->request.policies);
self->request.certificateSize = 0;
if (certificate && size) {
bailIfError(FskMemPtrNew(size, &self->request.certificate));
FskMemCopy(self->request.certificate, certificate, size);
self->request.certificateSize = size;
}
self->request.policies = FskStrDoCopy(policies);
bail:
return err;
}
void KPR_parseURI(xsMachine *the)
{
xsStringValue url = xsToString(xsArg(0));
KprURLPartsRecord parts;
xsStringValue target;
char c;
xsThrowIfFskErr(FskMemPtrNew(FskStrLen(url) + 1, &target));
FskStrCopy(target, url);
KprURLSplit(target, &parts);
xsResult = xsNewInstanceOf(xsObjectPrototype);
if (parts.scheme) {
c = *(parts.scheme + parts.schemeLength);
*(parts.scheme + parts.schemeLength) = 0;
xsNewHostProperty(xsResult, xsID_scheme, xsString(parts.scheme), xsDefault, xsDontScript);
*(parts.scheme + parts.schemeLength) = c;
}
if (parts.authority) {
c = *(parts.authority + parts.authorityLength);
*(parts.authority + parts.authorityLength) = 0;
xsNewHostProperty(xsResult, xsID_authority, xsString(parts.authority), xsDefault, xsDontScript);
*(parts.authority + parts.authorityLength) = c;
}
if (parts.path) {
c = *(parts.path + parts.pathLength);
*(parts.path + parts.pathLength) = 0;
xsNewHostProperty(xsResult, xsID_path, xsString(parts.path), xsDefault, xsDontScript);
*(parts.path + parts.pathLength) = c;
}
if (parts.name) {
c = *(parts.name + parts.nameLength);
*(parts.name + parts.nameLength) = 0;
xsNewHostProperty(xsResult, xsID_name, xsString(parts.name), xsDefault, xsDontScript);
*(parts.name + parts.nameLength) = c;
}
if (parts.query) {
c = *(parts.query + parts.queryLength);
*(parts.query + parts.queryLength) = 0;
xsNewHostProperty(xsResult, xsID_query, xsString(parts.query), xsDefault, xsDontScript);
*(parts.query + parts.queryLength) = c;
}
if (parts.fragment) {
c = *(parts.fragment + parts.fragmentLength);
*(parts.fragment + parts.fragmentLength) = 0;
xsNewHostProperty(xsResult, xsID_fragment, xsString(parts.fragment), xsDefault, xsDontScript);
*(parts.fragment + parts.fragmentLength) = c;
}
FskMemPtrDispose(target);
}
FskErr KprMemoryBufferNew(UInt32 size, KprMemoryBuffer *it)
{
FskErr err = kFskErrNone;
UInt32 recSize = sizeof(KprMemoryBufferRecord) + size + 1;
KprMemoryBuffer self;
bailIfError(FskMemPtrNew(recSize, &self));
FskMemSet(self, 0, sizeof(KprMemoryBufferRecord));
self->size = size;
self->buffer = (char *)self + sizeof(KprMemoryBufferRecord);
((char *)self->buffer)[size] = 0;
*it = self;
bail:
return err;
}
static char *getVolumeName(const struct statfs *fs)
{
CFStringRef nameRef;
char *name;
if (getVolumeProperty(fs->f_mntonname, kCFURLVolumeNameKey, (void *)&nameRef) && nameRef != NULL) {
int len = CFStringGetLength(nameRef);
if (FskMemPtrNew(len + 1, (FskMemPtr *)&name) != kFskErrNone)
return NULL;
CFStringGetCString(nameRef, name, len + 1, kCFStringEncodingUTF8);
CFRelease(nameRef);
return name;
}
else
return NULL;
}
static FskErr KprWebSocketEndpointCreateFrame(Boolean fin, UInt8 opcode, Boolean mask, void *payload, UInt32 length, void **frame, UInt32 *frameLength)
{
FskErr err = kFskErrNone;
UInt8 headers[14], maskData[4];
UInt32 headerLen = 1 + 1;
headers[0] = opcode;
if (fin) {
headers[0] |= 0x80u;
}
if (length < 126) {
headers[1] = (UInt8) length;
} else if (length < 0x10000l) {
headers[1] = 126;
*((UInt16 *)&headers[2]) = FskEndianU16_NtoB(length);
headerLen += sizeof(UInt16);
} else {
headers[1] = 127;
*((FskInt64 *)&headers[2]) = FskEndianU64_NtoB(length);
headerLen += sizeof(FskInt64);
}
if (mask) {
headers[1] |= 0x80u;
*((SInt32 *)maskData) = FskRandom();
FskMemCopy(&headers[headerLen], maskData, sizeof(maskData));
headerLen += sizeof(UInt32);
}
bailIfError(FskMemPtrNew(headerLen + length, frame));
FskMemCopy(*frame, headers, headerLen);
if (length > 0) {
FskMemCopy((UInt8 *) *frame + headerLen, payload, length);
}
*frameLength = headerLen + length;
if (mask) {
KprWebSocketMask((UInt8 *) *frame + headerLen, length, maskData);
}
bail:
return err;
}
void on_drag_data_received(GtkWidget* widget, GdkDragContext* context, gint x, gint y, GtkSelectionData *data, guint info, guint time, gpointer user_data)
{
FskGtkWindow gtkWin = user_data;
gboolean dnd_success = FALSE;
FskDragDropFile dropFileList = NULL;
FskDragDropFile droppedFile = NULL;
char* path = NULL;
if (gdk_drag_context_get_suggested_action(context) == GDK_ACTION_COPY) {
char* string = (char*)gtk_selection_data_get_data(data);
char* end;
FskFileInfo itemInfo;
for (end = FskStrStr(string, "\r\n"); end; end = FskStrStr(string, "\r\n")) {
BAIL_IF_ERR(FskMemPtrNewClear(sizeof(FskDragDropFileRecord), (FskMemPtr*)&droppedFile));
FskListAppend((FskList *)&dropFileList, droppedFile);
*end = 0;
BAIL_IF_ERR(KprURLToPath(string, &path));
BAIL_IF_ERR(FskFileGetFileInfo(path, &itemInfo));
if (itemInfo.filetype == kFskDirectoryItemIsDirectory) {
int length = FskStrLen(path);
BAIL_IF_ERR(FskMemPtrNew(length + 2, &droppedFile->fullPathName));
FskMemCopy(droppedFile->fullPathName, path, length);
droppedFile->fullPathName[length] = '/';
droppedFile->fullPathName[length + 1] = 0;
FskMemPtrDispose(path);
}
else {
droppedFile->fullPathName = path;
}
path = NULL;
string = end + 2;
*end = '\r';
}
(*gDropTargetProc)(kFskDragDropTargetEnterWindow, x, y, dropFileList, gtkWin->owner);
(*gDropTargetProc)(kFskDragDropTargetDropInWindow, x, y, dropFileList, gtkWin->owner);
dnd_success = TRUE;
}
bail:
gtk_drag_finish(context, dnd_success, TRUE, time);
FskMemPtrDispose(path);
while (NULL != dropFileList) {
droppedFile = dropFileList;
FskListRemove((FskList *)&dropFileList, droppedFile);
FskMemPtrDispose(droppedFile->fullPathName);
FskMemPtrDispose(droppedFile);
}
}
