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