自学教程：C++ FskMemPtrNew函数代码示例

voidxs_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 FskErrFillJaggyPolygonContours(	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);	}}