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

FskErr KplVolumeGetInfo(UInt32 volumeID, char **pathOut, char **nameOut, UInt32 *volumeType, Boolean *isRemovable, KplInt64 *capacity, KplInt64 *freeSpace){	volInfoRec *vi;	FskErr	err = kFskErrOperationFailed;	if (!volumeList)		scanVolumes();	vi = volumeList;	while (vi) {		if (volumeID == (UInt32)vi) {			if (pathOut)				*pathOut = FskStrDoCopy(vi->mountPoint);			if (nameOut)				*nameOut = FskStrDoCopy(vi->name);			if (volumeType)				*volumeType = vi->type;			if (isRemovable)				*isRemovable = vi->removable;			if (capacity)				*capacity = vi->capacity;			if (freeSpace)				*freeSpace = vi->remaining;			err = kFskErrNone;			break;		}		vi = vi->next;	}	return err;}

// ---------------------------------------------------------------------FskErr FskFSVolumeIteratorGetNext(FskFSVolumeIterator volIt, UInt32 *id, char **path, char **name){	FskErr ret = kFskErrIteratorComplete;	if (volIt) {		pMount theMount = gMounts;		while (theMount) {			if (theMount->fsID >= volIt->iter) {				break;			}			theMount = theMount->next;		}		if (!theMount) {			return ret;		}		if (id)			*id = theMount->fsID;		if (path) *path = FskStrDoCopy(theMount->mountPoint);		if (name) *name = FskStrDoCopy(theMount->name);		FskAndroidFilesPrintfDebug("VolIterGetNext iter: %d - path: %s/n", theMount->fsID, theMount->mountPoint);		volIt->iter = theMount->fsID + 1;		ret = kFskErrNone;	}	return ret;}

FskErr KprZeroconfServiceInfoNew(KprZeroconfServiceInfo *it, const char* type, const char* name, const char* host, const char* ip, UInt32 port, const UInt32 interfaceIndex, char* txt){    FskErr err = kFskErrNone;    KprZeroconfServiceInfo self = NULL;    bailIfError(FskMemPtrNewClear(sizeof(KprZeroconfServiceInfoRecord), it));    self = *it;    self->type = FskStrDoCopy(type);    bailIfNULL(self->type);    self->name = FskStrDoCopy(name);    bailIfNULL(self->name);    if (host) {        self->host = FskStrDoCopy(host);        bailIfNULL(self->host);    }    if (ip) {        self->ip = FskStrDoCopy(ip);        bailIfNULL(self->ip);    }    self->port = port;    self->interfaceIndex = interfaceIndex;    if (txt) {        self->txt = FskStrDoCopy(txt);        bailIfNULL(self->txt);    }    FskInstrumentedItemNew(self, NULL, &KprZeroconfServiceInfoInstrumentation);bail:    if (err)        KprZeroconfServiceInfoDispose(self);    return err;}

void Library_cacheQuery(xsMachine* the){    KprLibraryServer self = gLibraryServer;    UInt32 index;    KprLibraryQuery query;    FskMutexAcquire(self->queryMutex);    index = self->queryIndex % kQueryCount;    query = self->queries[index];    if (query) {        KprLibraryQueryDispose(query);        self->queries[index] = NULL;    }    KprLibraryQueryNew(&query);    FskInstrumentedItemSetOwner(query, self);    xsEnterSandbox();    query->index = self->queryIndex;    query->info = FskStrDoCopy(xsToString(xsGet(xsArg(0), xsID("info"))));    query->kind = xsToInteger(xsGet(xsArg(0), xsID("kind")));    query->mime = FskStrDoCopy(xsToString(xsGet(xsArg(0), xsID("mime"))));    query->url = FskStrDoCopy(xsToString(xsGet(xsArg(0), xsID("url"))));    xsResult = xsGet(xsArg(0), xsID("authorization"));    if (xsTest(xsResult))        query->authorization = FskStrDoCopy(xsToString(xsResult));    xsLeaveSandbox();    self->queries[index] = query;    xsResult = xsInteger(self->queryIndex);    self->queryIndex++;    FskMutexRelease(self->queryMutex);}

void KPR_debug_file(xsMachine *the){	KprDebug self = xsGetHostData(xsThis);	KprDebugMachine machine = NULL;	int command = mxNoCommand;	char* path = NULL;	char* value = NULL;	xsIntegerValue line = -1;	xsIntegerValue c = xsToInteger(xsArgc);	xsVars(4);	if ((c >= 2) && (xsTypeOf(xsArg(0)) == xsStringType) && (xsTypeOf(xsArg(1)) == xsIntegerType)) {		char* address = xsToString(xsArg(0));		command = xsToInteger(xsArg(1));		machine = KprDebugFindMachine(self, address);	}	if ((c >= 4) && (xsTypeOf(xsArg(2)) == xsStringType) && (xsTypeOf(xsArg(3)) == xsIntegerType)) {		path = FskStrDoCopy(xsToString(xsArg(2)));		line = xsToInteger(xsArg(3));	}	if ((c >= 5) && (xsTypeOf(xsArg(4)) == xsStringType)) {		value = FskStrDoCopy(xsToString(xsArg(4)));	}	if (machine && ((command == mxFramesView) || (command == mxFilesView) || (command == mxLogView) || (command == mxBreakpointsView))) {		xsEnterSandbox();		KprDebugMachineDispatchCommand(machine, command, path, value, line);		xsLeaveSandbox();	}	else		xsThrowIfFskErr(kFskErrInvalidParameter);	FskMemPtrDispose(value);	FskMemPtrDispose(path);}

FskErr KprWebSocketEndpointConnect(KprWebSocketEndpoint self, char *url, char *origin){	FskErr err = kFskErrNone;		self->url = FskStrDoCopy(url);	bailIfNULL(self->url);	bailIfError(FskStrParseUrl(self->url, &self->parts));	if (!KprWebSocketEndpointCheckURL(self)) {		bailIfError(kFskErrInvalidParameter);	}		self->isSecure = (FskStrCompare(self->parts->scheme, "wss") == 0);		if (origin) {		self->origin = FskStrDoCopy(origin);		bailIfNULL(self->origin);	}		self->state = kKprWebSocketStateConnecting;		INVOKE_AFTER1(KprWebSocketEndpointStartConnect, self);	bail:	return err;}

FskErr KprDBStatementNew(KprDBStatement* it, KprDB db, const char* text, char* bindFormat, char* rowFormat){	FskErr err = kFskErrNone;	KprDBStatement self = NULL;	SInt32 count, size, i;	bailIfError(KprMemPtrNewClear(sizeof(KprDBStatementRecord), it));	self = *it;	FskInstrumentedItemNew(self, NULL, &KprDBStatementInstrumentation);	bailIfError(sqlite3_prepare_v2(db->data, text, FskStrLen(text), &self->data, NULL));	count = sqlite3_bind_parameter_count(self->data);	if (count && !bindFormat) BAIL(kFskErrInvalidParameter);	if (!count && bindFormat) BAIL(kFskErrInvalidParameter);	if (count) {		if ((SInt32)FskStrLen(bindFormat) != count) BAIL(kFskErrInvalidParameter);		self->bindFormat = FskStrDoCopy(bindFormat);		bailIfNULL(self->bindFormat);	}	count = sqlite3_column_count(self->data);	if (count && !rowFormat) BAIL(kFskErrInvalidParameter);	if (!count && rowFormat) BAIL(kFskErrInvalidParameter);	if (count) {		if ((SInt32)FskStrLen(rowFormat) != count) BAIL(kFskErrInvalidParameter);		self->rowFormat = FskStrDoCopy(rowFormat);		bailIfNULL(self->rowFormat);		bailIfError(KprMemPtrNewClear(count * sizeof(char*), &self->keys));		for (size = 0, i = 0; rowFormat[i]; i++) {			self->keys[i] = sqlite3_column_name(self->data, i);			switch (rowFormat[i]) {				case 'b':					size += sizeof(void*) + sizeof(UInt32);					break;				case 'd':					size += sizeof(double);					break;				case 'i':					size += sizeof(SInt32);					break;				case 'I':					size += sizeof(FskInt64);					break;				case 'r':					size += sizeof(SInt32);					break;				case 't':					size += sizeof(char*);					break;				default:					BAIL(kFskErrInvalidParameter);					break;			}		}		bailIfError(KprMemPtrNewClear(size, &self->values));	}bail:	if (err)		KprDBStatementDispose(self);	return err;}

FskErr FskFSVolumeGetInfo(UInt32 volumeID, char **pathOut, char **nameOut, UInt32 *volumeType, Boolean *isRemovable, FskInt64 *capacity, FskInt64 *freeSpace){	FskInt64 calc, more;	pMount theMount;	FskErr	err = kFskErrOperationFailed;	struct statfs volStat;	if (!gMounts)		scanVolumes();	theMount = gMounts;	FskAndroidFilesPrintfDebug("FSVolumeGetInfo for id %d/n", volumeID);	if (capacity)		*capacity = 0;	if (freeSpace)		*freeSpace = 0;	while (theMount) {		if (theMount->fsID == (SInt32)volumeID) {			break;		}		theMount = theMount->next;	}	if (theMount) {		if (pathOut)		*pathOut = FskStrDoCopy(theMount->mountPoint);		if (nameOut)		*nameOut = FskStrDoCopy(theMount->name);		if (volumeType)		*volumeType = theMount->type;		if (isRemovable)	*isRemovable = theMount->removable;		FskAndroidFilesPrintfDebug("getInfo returns - path: %s, name: %s, ", theMount->mountPoint, theMount->name);		statfs(theMount->mountPoint, &volStat);		if (capacity) {			calc = volStat.f_bsize;			more = volStat.f_blocks;			calc = calc * more;			*capacity = calc;			FskAndroidFilesPrintfDebug("capacity %d,", calc);		}		if (freeSpace) {			calc = volStat.f_bsize;			more = volStat.f_bavail;			calc = calc * more;			*freeSpace = calc;			FskAndroidFilesPrintfDebug("freeSpace %d", calc);		}		err = kFskErrNone;	}	else {		FskAndroidFilesPrintfDebug("getInfo fails/n");	}	return err;}

FskErr mp3ReaderSniff(const unsigned char *data, UInt32 dataSize, FskHeaders *headers, const char *uri, char **mime){	UInt32 i;	// check data for ID3 tag (as per section 3.1 of id3 spec)	if (dataSize >= 10) {		if (('I' == data[0]) & ('D' == data[1]) & ('3' == data[2])) {			if ((data[3] != 0xff) && (data[4] != 0xff)) {				if (0 == (data[5] & 0x1f)) {					if ((data[6] < 0x80) && (data[7] < 0x80) && (data[8] < 0x80) && (data[9] < 0x80)) {						*mime = FskStrDoCopy("audio/mpeg");		// could also be AAC depending on codec tag or actual bitstream. but this is enough to get it routed to this media player.						return kFskErrNone;					}				}			}		}	}	for (i = 0; (i < 2) && (dataSize >= 10); i++) {		const unsigned char *d = data, *e = data + dataSize - 7;		// - 7 to account for the max header size of mp3 & aac/adts		UInt32 ds = dataSize;		Boolean	(*doHeaderParse)(unsigned char *scan, DIDLMusicItem mi);		doHeaderParse = (0 == i) ? parseMP3Header : parseADTSHeader;		while (d < e) {			DIDLMusicItemRecord mi0, mi1, mi2;			mi0.doExtendedParsing = 0;			mi1.doExtendedParsing = 0;			mi2.doExtendedParsing = 0;			if (true == (doHeaderParse)((unsigned char *)d, &mi0)) {				if ((d + mi0.frameLength + 7) < e) {					if (true == (doHeaderParse)((unsigned char *)(d + mi0.frameLength), &mi1)) {						if ((d + mi0.frameLength + mi1.frameLength + 7) < e) {							if (true == (doHeaderParse)((unsigned char *)(d + mi0.frameLength + mi1.frameLength), &mi2)) {								if ((mi0.frequency == mi1.frequency) && (mi0.channelCount == mi1.channelCount) &&									(mi0.frequency == mi2.frequency) && (mi0.channelCount == mi2.channelCount)) {									*mime = FskStrDoCopy((0 == i) ? "audio/mpeg" : "audio/vnd.dlna.adts");									return kFskErrNone;								}							}						}					}				}			}			d += 1;			ds -= 1;		}	}	return kFskErrUnknownElement;}

FskErr KplVolumeGetDeviceInfo(UInt32 volumeID, char **vendor, char **product, char **revision, char **vendorSpecific) {	if (vendor)		*vendor = FskStrDoCopy("vendor");	if (product)		*product = FskStrDoCopy("product");	if (revision)		*revision = FskStrDoCopy("1.0");	if (vendorSpecific)		*vendorSpecific = FskStrDoCopy("vendorSpecific");	return kFskErrNone;}

FskErr KprMessageSetCredentials(KprMessage self, char* user, char* password){	FskErr err = kFskErrNone;	FskMemPtrDisposeAt(&self->user);	FskMemPtrDisposeAt(&self->password);	if (user && password) {		self->user = FskStrDoCopy(user);		bailIfNULL(self->user);		self->password = FskStrDoCopy(password);		bailIfNULL(self->password);	}bail:	return err;}

FskErr FskFSVolumeGetInfo(UInt32 volumeID, char **pathOut, char **nameOut, UInt32 *volumeType, Boolean *isRemovable, FskInt64 *capacity, FskInt64 *freeSpace){	FskErr err = kFskErrNone;	struct statfs *fs;	if (volumeID >= (UInt32)gNumStatFS)		return kFskErrInvalidParameter;	fs = &gStatFS[volumeID];	if (pathOut)		*pathOut = FskStrDoCopy(fs->f_mntonname);	if (nameOut)		*nameOut = FskStrDoCopy(FskCocoaDisplayNameAtPath(fs->f_mntonname));	if (capacity)		*capacity = fs->f_blocks * fs->f_bsize;	if (freeSpace)		*freeSpace = fs->f_bavail * fs->f_bsize;	if (isRemovable)		*isRemovable = FskCocoaIsRemovable(fs->f_mntonname);	if (volumeType) {		*volumeType = kFskVolumeTypeUnknown;		if (!(fs->f_flags & MNT_LOCAL))			*volumeType = kFskVolumeTypeNetwork;		else if (FskStrCompare(fs->f_fstypename, "hfs") == 0 || FskStrCompare(fs->f_fstypename, "ufs") == 0)			*volumeType = kFskVolumeTypeFixed;		else if (FskStrCompare(fs->f_fstypename, "devfs") == 0)			*volumeType = kFskVolumeTypeUnknown;		else {			char *product;			if ((err = FskFSVolumeGetDeviceInfo(volumeID, NULL, &product, NULL, NULL)) != kFskErrNone)				return err;			if (product == NULL)				*volumeType = kFskVolumeTypeUnknown;			else if (FskStrStr(product, "MS") || FskStrStr(product, "WM-MS"))				*volumeType = kFskVolumeTypeMemoryStick;			else if (FskStrStr(product, "MMC"))				*volumeType = kFskVolumeTypeMMC;			else if (FskStrStr(product, "CF"))				*volumeType = kFskVolumeTypeCompactFlash;			else if (FskStrStr(product, "SM"))				*volumeType = kFskVolumeTypeSmartMedia;			else if (FskStrStr(product, "SD"))				*volumeType = kFskVolumeTypeSDMemory;			else				*volumeType = kFskVolumeTypeUnknown;		}	}	return err;}

void KPR_Message_cancelReferrer(xsMachine* the){	char* url = FskStrDoCopy(xsToString(xsArg(0)));	xsThrowIfNULL(url);	KprMessageCancelReferrer(url);	FskMemPtrDispose(url);}

FskErr KprWebSocketEndpointClose(KprWebSocketEndpoint self, UInt16 code, char *reason){	FskErr err = kFskErrNone;	FskDebugStr("CLOSE: (%d), %s/n", code, reason);	self->closeCode = code;	if (reason) {		FskMemPtrDispose(self->closeReason);		self->closeReason = FskStrDoCopy(reason);	}		switch (self->state) {		case kKprWebSocketStateConnecting:			bailIfError(KprWebSocketEndpointCancelConnection(self));			break;					case kKprWebSocketStateOpen:			bailIfError(KprWebSocketEndpointStartClosingHandshake(self, code, reason));			break;					case kKprWebSocketStateClosing:		case kKprWebSocketStateClosed:		default:			break;	}	bail:	return err;}

FskErr KprSocketConnect(KprSocket self, const char *host, int port){	FskErr err = kFskErrNone;	long flags = 0;	if (self->mode != kKprSocketModeUndefined) return kFskErrBadState;	self->host = FskStrDoCopy(host);	bailIfNULL(self->host);	self->port = port;	self->mode = kKprSocketModeTCP;	if (self->secure) {		FskSSLOption ssl;		flags |= kConnectFlagsSSLConnection;		FskNetSSLOptionInitialize(self->host, self->port, flags, kFskNetSocketDefaultPriority, &ssl);		ssl.protocolVersion = self->tlsProtocolVersion;		ssl.applicationProtocols = self->applicationProtocols;		bailIfError(FskNetConnectToSecureHost(&ssl, self->certs, KprSocketOnConnect, self));	} else {		bailIfError(FskNetConnectToHost((char *) self->host, self->port, false, KprSocketOnConnect, self, flags, NULL, "KprSocketTCP"));	}bail:	if (err) {		KprSocketCleanup(self);	}	return err;}

// ---------------------------------------------------------------------void sNotifyInterfaceNotifiers(FskNetInterfaceRecord *iface, UInt32 status) {	FskNetInterfaceNotifier callback = NULL, next;	FskThread thread = FskThreadGetCurrent();	callback = (FskNetInterfaceNotifier)FskListMutexGetNext(interfaceChangeCBList, NULL);	while (callback) {		next = (FskNetInterfaceNotifier)FskListMutexGetNext(interfaceChangeCBList, callback);#if 0 && SUPPORT_INSTRUMENTATION		if (FskInstrumentedItemHasListeners(callback)) {			FskNetInterfaceRecord *iface = (FskNetInterfaceRecord *)FskNetInterfaceFindByName(ifcName);			FskInterfaceInstrData data;			data.notf = callback;			data.ifc = iface;			data.status = status;			FskInstrumentedItemSendMessage(callback, kFskNetInstrMsgInterfaceNotify, &data);		}#endif /* SUPPORT_INSTRUMENTATION */		if (callback->thread != thread) {			FskNetInterfaceRecord *interFace;			if (kFskErrNone == FskMemPtrNewFromData(sizeof(FskNetInterfaceRecord), iface, &interFace)) {				interFace->next = NULL;				interFace->name = FskStrDoCopy(iface->name);				// POST notify				FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, " - posting callback to thread %s for interface %s", callback->thread->name, iface->name);				FskThreadPostCallback(callback->thread, doNetIfcCallback, (void*)callback->callback, (void*)interFace, (void*)status, (void*)callback->param);			}		}		else {			FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "callback->thread %s - call", callback->thread->name);			(callback->callback)(iface, status, callback->param);		}		callback = next;	}}

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

// ---------------------------------------------------------------------FskErr FskNetInterfaceDescribe(int idx, FskNetInterfaceRecord **iface){	int i = 0;	FskErr ret = kFskErrNone;	FskNetInterfaceRecord *nir;	FskMutexAcquire(gNetworkInterfaceList->mutex);	nir = (FskNetInterfaceRecord *)gNetworkInterfaceList->list;	while (nir) {		if (i == idx)			break;		nir = nir->next;		i++;	}	if (nir) {		FskNetInterfaceRecord *dup;		if (kFskErrNone == FskMemPtrNewFromData(sizeof(FskNetInterfaceRecord), nir, &dup)) {			dup->next = NULL;			dup->name = FskStrDoCopy(nir->name);		}		*iface = dup;	}	else {		*iface = NULL;		ret = kFskErrNetworkInterfaceNotFound;	}	FskMutexRelease(gNetworkInterfaceList->mutex);	return ret;}

FskErr mp3ReaderTrackGetMediaType(void *readerState, void *track, UInt32 propertyID, FskMediaPropertyValue property){	property->type = kFskMediaPropertyTypeString;	property->value.str = FskStrDoCopy("audio");	return kFskErrNone;}

FskErr KprCoAPClientResolverNew(KprCoAPClientResolver *it, KprCoAPClient client, const char *host, UInt16 port, KprCoAPMessage message){	FskErr err = kFskErrNone;	KprCoAPClientResolver self = NULL;	bailIfError(KprMemPtrNewClear(sizeof(KprCoAPClientResolverRecord), &self));	self->host = FskStrDoCopy(host);	bailIfNULL(self->host);	bailIfError(KprCoAPMessageQueueAppend(&self->waiting, message));	self->client = client;	self->port = port;	bailIfError(FskNetHostnameResolveQTAsync((char *) host, 0, KprCoAPClientResolverResolved, self, &self->resolver));	bailIfError(self->err);	self->constructed = true;	*it = self;bail:	if (err) {		KprCoAPClientResolverDispose(self);	}	return err;}

FskErr KprMQTTClientNew(KprMQTTClient* it, char *clientId, Boolean cleanSession, void *refcon){	FskErr err = kFskErrNone;	KprMQTTClient self = NULL;	bailIfError(FskMemPtrNewClear(sizeof(KprMQTTClientRecord), &self));	bailIfError(KprMQTTQueueNew(&self->queue, 15, KprMQTTClientSendMessageViaDelivery, self));	FskTimeCallbackNew(&self->pingRequestCallaback);	bailIfNULL(self->pingRequestCallaback);	FskTimeCallbackNew(&self->pingResponseCallaback);	bailIfNULL(self->pingResponseCallaback);	self->clientIdentifier = FskStrDoCopy(clientId);	bailIfNULL(self->clientIdentifier);	self->cleanSession = cleanSession;	self->refcon = refcon;	self->state = kKprMQTTStateDisconnected;	KprMQTTQueueStart(self->queue);	*it = self;bail:	if (err) KprMQTTClientDispose(self);	return err;}

static FskErr KprSocketNewFromFskSocket(FskSocket skt, KprSocketFlags flags, KprSocket *it){	FskErr err = kFskErrNone;	KprSocket self = NULL;	UInt32 ipaddr;	char ipaddrStr[22];	bailIfError(FskMemPtrNewClear(sizeof(KprSocketRecord), &self));	bailIfError(FskNetSocketGetLocalAddress(skt, &ipaddr, &self->port));	FskNetIPandPortToString(ipaddr, 0, ipaddrStr);	self->host = FskStrDoCopy(ipaddrStr);	bailIfNULL(self->host);	self->mode = kKprSocketModeTCP;	self->proto = kKprSocketProtoTCP;	self->secure = (Boolean)(flags & kKprSocketFlagsSecure);	bailIfError(KprSocketOnConnect(skt, self));	*it = self;	FskListAppend(&gSockets, self);bail:	if (err) {		KprSocketDispose(self);	}	return err;}

FskErr KplDirectoryIteratorGetNext(KplDirectoryIterator dirIt, char **name, UInt32 *itemType){	struct dirent *ent;	FskErr	err;	KplFileInfo finfo;	if (!dirIt || !dirIt->theDir)		return kFskErrInvalidParameter;	ent = readdir(dirIt->theDir);	if (!ent) {		return kFskErrIteratorComplete;	}	err = KplFileGetPathInfo((char *)dirIt->root, ent->d_name, &finfo);	if (err != kFskErrNone)		return err;	if (itemType)		*itemType = finfo.filetype;    if ('.' == ent->d_name[0]) {        if ((0 == (dirIt->flags & 1)) ||            (0 == FskStrCompare(ent->d_name, ".")) ||            (0 == FskStrCompare(ent->d_name, "..")))            return KplDirectoryIteratorGetNext(dirIt, name, itemType);        // skip hidden files    }    if (name)        *name = FskStrDoCopy(ent->d_name);	return kFskErrNone;}

static FskErr KprWebSocketServerRequestNew(KprWebSocketServerRequest *it, KprWebSocketServer server, FskSocket skt, const char *interfaceName, int ip) {	FskErr err = kFskErrNone;	KprWebSocketServerRequest request = NULL;	bailIfError(FskMemPtrNewClear(sizeof(KprWebSocketServerRequestRecord), &request));	request->server = server;	request->skt = skt;	skt = NULL;	request->interfaceName = FskStrDoCopy(interfaceName);	bailIfNULL(request->interfaceName);	request->ip = ip;	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;}

static FskErrnewSSLVM(FskECMAScript *vmp){	FskECMAScript vm;	FskErr err;#ifdef KPR_CONFIG	if ((err = FskMemPtrNewClear(sizeof(FskECMAScriptRecord), &vm)) != kFskErrNone)		return err;	if ((vm->the = xsAliasMachine(&anAllocation, gShell->root, "SSL", vm)) == NULL) {		FskMemPtrDispose(vm);		return kFskErrMemFull;	}#else	if (gSSLVM == NULL)		return kFskErrUnimplemented;	if ((err = FskMemPtrNewFromData(sizeof(FskECMAScriptRecord), gSSLVM, &vm)) != kFskErrNone)		return err;	vm->the = NULL;	vm->context = NULL;	vm->refcon = NULL;	vm->libraries = NULL;	vm->name = FskStrDoCopy("SSL");	vm->thread = FskThreadGetCurrent();	vm->id = (UInt32)vm;	if ((vm->the = xsAliasMachine(&anAllocation, gSSLVM->the, vm->name, vm)) == NULL) {		FskMemPtrDispose(vm);		return kFskErrMemFull;	}#endif	*vmp = vm;	return err;}

FskErr FskTextFreeTypeInstallFonts(char* fontsPath, char* defaultFont){	FskErr err = kFskErrNone;	FskTextEngine fte;	char *fromDirectory = NULL;	char *fromPath = NULL;	FskDirectoryIterator iterator = NULL;	char *name = NULL;	UInt32 type;	err = FskTextEngineNew(&fte, NULL);	if (err) goto bail;	fromDirectory = FskEnvironmentDoApply(FskStrDoCopy(fontsPath));	if (!fromDirectory) { err = kFskErrMemFull; goto bail; }		err = FskDirectoryIteratorNew(fromDirectory, &iterator, 0);	if (err) goto bail;	while (kFskErrNone == FskDirectoryIteratorGetNext(iterator, &name, &type)) {		if (type == kFskDirectoryItemIsFile) {			fromPath = FskStrDoCat(fromDirectory, name);			if (!fromPath) { err = kFskErrMemFull; goto bail; }			FskTextAddFontFile(fte, fromPath);			FskMemPtrDisposeAt(&fromPath);		}		FskMemPtrDisposeAt(&name);	}bail:	FskTextEngineDispose(fte);	FskMemPtrDispose(fromDirectory);	FskDirectoryIteratorDispose(iterator);	return err;}

static FskErr KprMQTTClientCreatePublishMessage(KprMQTTClient self, char *topic, void *payload, UInt32 payloadLength, UInt8 qos, Boolean retain, KprMQTTMessage *it){	FskErr err;	KprMQTTMessage message = NULL;	bailIfError(KprMQTTMessageNewWithType(&message, kKprMQTTMessageTypePUBLISH));	message->qualityOfService = qos;	message->isRetained = retain;	if (qos > 0) {		message->messageId = KprMQTTQueueNextId(self->queue);	}	message->t.publish.topic = FskStrDoCopy(topic);	bailIfNULL(message->t.publish.topic);	bailIfError(KprMemoryBufferNewFromData(payloadLength, payload, &message->t.publish.payload));	*it = message;	message = NULL;bail:	KprMQTTMessageDispose(message);	return err;}

void KprZeroconfServiceDiscover(KprService self, char* authority, char* id, Boolean useEnvironment){	FskErr err = kFskErrNone;	char* type = NULL;	KprZeroconfBrowser browser = NULL;	if (useEnvironment ? KprEnvironmentGetUInt32("useZeroconf", 0) : true) {		bailIfError(KprZeroconfServiceNewType(id, &type));		browser = KprZeroconfBrowserFind(gKprZeroconfBrowsers, type);		if (!browser) {			bailIfError(KprZeroconfBrowserNew(&browser, type));			browser->serviceUpCallback = KprZeroconfServiceServiceUpCallback;			browser->serviceDownCallback = KprZeroconfServiceServiceDownCallback;			browser->authority = FskStrDoCopy(authority);			bailIfError(KprZeroconfBrowserStart(browser));			FskListAppend(&gKprZeroconfBrowsers, browser);		}	}bail:	if (err)		KprZeroconfBrowserDispose(browser);	FskMemPtrDispose(type);	FskMemPtrDispose(authority);	FskMemPtrDispose(id);	return;}

FskErr KprMQTTClientConnect(KprMQTTClient self, char *host, UInt16 port, KprMQTTClientConnectOptions *options){	FskErr err = kFskErrNone;	if (self->state != kKprMQTTStateDisconnected) {		return kFskErrBadState;	}	FskMemPtrDisposeAt(&self->host);	self->host = FskStrDoCopy(host);	bailIfNULL(self->host);	self->port = port;	self->cancelConnection = false;	KprMQTTMessageDispose(self->connectMessage);	self->connectMessage = NULL;	bailIfError(KprMQTTClientCreateConnectMessage(self, options, &self->connectMessage));	self->keepAlive = options->keepAlive;	bailIfError(KprMQTTClientReconnect(self));bail:	return err;}

FskErr latmPacketParserGetInfo(RTPPacketParser parser, UInt32 selector, void *info, UInt32 *infoSize){	LATMPacketParser latmPacketParser = (LATMPacketParser)parser->handlerRefCon;	FskErr err = 0;	switch(selector) {		case kRTPPacketParserSelectorESDS:			*(UInt8**)info = latmPacketParser->esds;			if (infoSize)				*infoSize = latmPacketParser->esdsSize;			break;		case kRTPPacketParserSelectorRTPTimeScale:		case kRTPPacketParserSelectorAudioSampleRate:			*(UInt32*)info = latmPacketParser->sampleRate;			break;		case kRTPPacketParserSelectorAudioChannels:			*(UInt32*)info = latmPacketParser->nChannels;			break;		case kRTPPacketParserSelectorAudioBitsPerSample:			*(UInt32*)info = latmPacketParser->bitsPerSample;			break;		case kRTPPacketParserSelectorMediaFormat:			*(UInt32*)info = latmPacketParser->mediaFormat;			break;		case kRTPPacketParserSelectorEncodingName:			*(UInt8**)info = (UInt8*)FskStrDoCopy("MP4A-LATM");			break;		default:			err = kFskErrInvalidParameter;			break;	}	return err;}