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;
}
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 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;
}
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;
}
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 FskGPIONew(FskGPIO *gpioOut, int pin, char *pinName, GPIOdirection direction)
{
FskErr err = kFskErrNone;
FskGPIO gpio = NULL;
err = FskMemPtrNewClear(sizeof(FskGPIORecord), (FskMemPtr *)&gpio);
BAIL_IF_ERR(err);
gpio->pinNum = pin;
gpio->realPin = FskHardwarePinsMux(pin, kFskHardwarePinGPIO);
gpio->thread = FskThreadGetCurrent();
if (gpio->realPin < 0)
BAIL(kFskErrInvalidParameter);
err = FskGPIOPlatformInit(gpio);
BAIL_IF_ERR(err);
if (undefined != direction) {
err = FskGPIOPlatformSetDirection(gpio, direction);
BAIL_IF_ERR(err);
}
bail:
if (err && gpio) {
FskGPIOPlatformDispose(gpio);
FskMemPtrDisposeAt(&gpio);
}
*gpioOut = gpio;
return err;
}
FskErr KprMessageSetMethod(KprMessage self, char* method)
{
FskErr err = kFskErrNone;
FskMemPtrDisposeAt(&self->method);
if (method) {
self->method = FskStrDoCopy(method);
bailIfNULL(self->method);
}
bail:
return err;
}
void KprModulesBasesCleanup(void)
{
if (gModulesBases) {
UInt32 i = 1;
while (i < gModulesBasesCount) {
FskMemPtrDispose(gModulesBases[i]);
i++;
}
FskMemPtrDisposeAt(&gModulesBases);
gModulesBasesCount = 0;
}
}
static void
disposeSSLRootVM()
{
#ifdef KPR_CONFIG
#else
if (gSSLVM != NULL) {
if (gSSLVM->the != NULL)
xsDeleteMachine(gSSLVM->the);
FskMemPtrDisposeAt(&gSSLVM);
}
#endif
}
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;
}
FskHTTPServerListener FskHTTPServerListenerNew(FskHTTPServer http, int port, char *interfaceName) {
FskHTTPServerListener listener;
FskErr err;
FskSocket skt;
FskNetInterfaceRecord *ifc = NULL;
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerListenerNew - interfaceName: %s\n", interfaceName);
err = FskMemPtrNewClear(sizeof(FskHTTPServerListenerRecord), (FskMemPtr*)&listener);
BAIL_IF_ERR(err);
listener->http = http;
listener->port = port;
listener->ifcName = FskStrDoCopy(interfaceName);
err = FskNetSocketNewTCP(&skt, true, "HTTP Server");
if (err) {
FskInstrumentedItemSendMessage(listener->http, kFskHTTPInstrMsgErrString, "listener socket create failed.");
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerListenerNew - creating socket failed: %d\n", err);
BAIL(kFskErrNoMoreSockets);
}
FskNetSocketReuseAddress(skt);
ifc = FskNetInterfaceFindByName(listener->ifcName);
if ((NULL == ifc) ||
(kFskErrNone != (err = FskNetSocketBind(skt, ifc->ip, listener->port)))) {
FskNetSocketClose(skt);
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerListenerNew - bind failed: %d port: %d\n", err, listener->port);
listener->http->stats.connectionsAborted++;
if (listener->http->callbacks)
err = doCallCondition(listener->http->callbacks->serverCondition, listener->http, kFskHTTPConditionNoSocket, listener->http->refCon);
goto bail;
}
listener->skt = skt;
FskNetSocketMakeNonblocking(skt);
FskListAppend((FskList*)&listener->http->listeners, listener);
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerListenerNew - about to listen\n");
FskNetSocketListen(skt);
FskThreadAddDataHandler(&listener->dataHandler, (FskThreadDataSource)skt, (FskThreadDataReadyCallback)httpServerListenerAcceptNewConnection, true, false, listener);
FskInstrumentedItemSendMessage(listener->http, kFskHTTPInstrMsgNowListening, listener);
bail:
FskNetInterfaceDescriptionDispose(ifc);
if (err) {
FskInstrumentedItemSendMessage(listener->http, kFskHTTPInstrMsgFailedListener, listener);
FskMemPtrDisposeAt((void**)&listener);
}
return listener;
}
FskErr KplAudioDispose(KplAudio audio)
{
FskErr err = kFskErrNone;
if (!audio) goto bail;
if (audio->thread) {
audio->stopping = true;
FskThreadJoin(audio->thread);
}
KplMutexDispose(audio->mutex);
audio->mutex = NULL;
FskMemPtrDisposeAt(&audio->data);
FskMemPtrDispose(audio);
bail:
return err;
}
FskErr KplScreenDisposeBitmap(KplBitmap bitmap)
{
if (bitmap != gKplScreen->bitmap)
return kFskErrOperationFailed;
if (gKplScreen) {
if (gKplScreen->flipThread)
FskThreadJoin(gKplScreen->flipThread);
FskMemPtrDispose(gKplScreen->bitmap);
FskMemPtrDisposeAt(&gKplScreen);
FskSemaphoreDispose(gKplScreen->flipSemaphore);
}
terminateLinuxInput();
return kFskErrNone;
}
void KprDebugMachineDispose(KprDebugMachine self)
{
if (self) {
KprDebug debug = self->debug;
xsBeginHostSandboxCode(debug->the, debug->code);
xsVars(1);
KprDebugMachineCallbackText(self, "onMachineUnregistered", mxNoCommand, NULL);
xsEndHostSandboxCode();
FskListRemove(&self->debug->machine, self);
KprSocketWriterDispose(self->writer);
self->writer = NULL;
FskThreadRemoveDataHandler(&self->reader);
FskNetSocketClose(self->socket);
self->socket = NULL;
FskMemPtrDisposeAt(&self->title);
FskInstrumentedItemDispose(self);
FskMemPtrDispose(self);
}
}
// ---------------------------------------------------------------------
// Directory Iterator
// ---------------------------------------------------------------------
FskErr FskFSDirectoryIteratorNew(const char *directoryPath, FskFSDirectoryIterator *dirIt, UInt32 flags)
{
FskFSDirectoryIterator di = NULL;
FskErr err;
FskFileInfo itemInfo;
FskAndroidFilesPrintfDebug("FSDirectoryIteratorNew: %s\n", directoryPath);
if (directoryPath[FskStrLen(directoryPath) -1] != '/')
BAIL(kFskErrInvalidParameter);
err = FskFSFileGetFileInfo(directoryPath, &itemInfo);
BAIL_IF_ERR(err);
if (itemInfo.filetype != kFskDirectoryItemIsDirectory)
BAIL(kFskErrNotDirectory);
err = FskMemPtrNew(sizeof(FskFSDirectoryIteratorRecord), (FskMemPtr*)(void*)&di);
BAIL_IF_ERR(err);
di->root = (unsigned char *)FskStrDoCopy(directoryPath);
di->theDir = opendir(directoryPath);
if (di->theDir == NULL) {
FskMemPtrDisposeAt(&di->root);
BAIL(errnoToFskErr(err));
}
di->device = itemInfo.fileDevice;
*dirIt = (FskFSDirectoryIterator)di;
err = kFskErrNone;
bail:
if (err) {
if (di && di->root)
FskMemPtrDispose(di->root);
if (di)
FskMemPtrDispose(di);
}
return err;
}
void KprHTTPClientStop(KprService service)
{
KprHTTPClient self = gKprHTTPClient;
KprHTTPConnection connection;
KprHTTPTarget target;
/* CONNECTIONS */
while ((connection = self->connections)) {
FskListRemove(&self->connections, connection);
KprHTTPConnectionDispose(connection);
}
while ((target = self->targets)) {
FskListRemove(&self->targets, target);
// @@ cancel message?
}
/* KEYCHAIN */
if (self->keychain) {
KprHTTPKeychainWrite(self->keychain);
KprHTTPKeychainDispose(self->keychain);
self->keychain = NULL;
}
/* COOKIES */
if (self->cookies) {
KprHTTPCookiesCleanup(self->cookies, true);
KprHTTPCookiesWrite(self->cookies);
KprHTTPCookiesDispose(self->cookies);
self->cookies = NULL;
}
/* HTTP CACHE */
if (self->cache) {
KprHTTPCacheWrite(self->cache);
KprHTTPCacheDispose(self->cache);
self->cache = NULL;
}
FskInstrumentedItemDispose(self);
FskMemPtrDisposeAt(&gKprHTTPClient);
}
FskErr mp3ReaderExtract(FskMediaReader reader, void *readerState, FskMediaReaderTrack *track, UInt32 *infoCount, FskMediaReaderSampleInfo *info, unsigned char **dataOut)
{
mp3Reader state = readerState;
FskErr err = kFskErrNone;
UInt32 spaceInOutput;
unsigned char *data;
FskMediaReaderSampleInfo lastInfo = NULL;
UInt32 infoCountFree;
#if SUPPORT_MP3_LOG_TO_FILE
UInt32 outputSize;
#endif
spaceInOutput = (state->mi.bitrate * 128) / 2; // about half a second
if (spaceInOutput < 4096)
spaceInOutput = 4096;
#if SUPPORT_MP3_LOG_TO_FILE
outputSize = spaceInOutput;
#endif
*track = &state->track;
*infoCount = 0;
*info = NULL;
infoCountFree = state->mi.frequency >> 11; // quick divide by 2048... allocate enough entries for about half a second of frames
err = FskMemPtrNew(infoCountFree * sizeof(FskMediaReaderSampleInfoRecord), (FskMemPtr*)(void*)info);
if (err) return err;
err = FskMemPtrNew(spaceInOutput + kFskDecompressorSlop, (FskMemPtr *)&data);
if (err) {
FskMemPtrDisposeAt((void **)info);
return err;
}
*dataOut = data;
while (0 != infoCountFree) {
if (state->hasEndTime && (state->atTime >= state->endTime)) {
if (0 == *infoCount )
err = kFskErrEndOfFile;
goto bail;
}
if ((state->readBufferEnd - state->readBufferPtr) < 6) {
err = mp3RefillReadBuffer(state, 6);
if (err) goto bail;
}
if ((0xff == state->readBufferPtr[0]) && (0xe0 == (state->readBufferPtr[1] & 0xe0))) {
DIDLMusicItemRecord mi;
mi.doExtendedParsing = 0;
if (true == (state->doHeaderParse)(state->readBufferPtr, &mi)) {
if (spaceInOutput < mi.frameLength)
goto bail;
if ((state->readBufferEnd - state->readBufferPtr) < (SInt32)mi.frameLength) {
err = mp3RefillReadBuffer(state, mi.frameLength);
if (err) goto bail;
}
// When starting from a new location, make extra sure we're really sitting on a valid frame,
// by validating the next frame.
if (state->resync) {
if (state->readBufferEnd - (state->readBufferPtr + mi.frameLength) > 6) {
DIDLMusicItemRecord mi2;
UInt8 *nextFramePtr = state->readBufferPtr + mi.frameLength;
if ((0xff != nextFramePtr[0]) || (0xe0 != (nextFramePtr[1] & 0xe0))) {
state->readBufferPtr += 1;
continue;
}
mi2.doExtendedParsing = 0;
if (false == (state->doHeaderParse)(nextFramePtr, &mi2)) {
state->readBufferPtr += 1;
continue;
}
}
state->resync = false;
}
if (kFskAudioFormatAACADTS == mi.codec) { // skip adts header to get to raw aac frame. @@ if frame Count != 1 this isn't going to work
mi.frameLength -= 7;
state->readBufferPtr += 7;
}
if ((NULL != lastInfo) && (lastInfo->sampleDuration = mi.samplesPerFrame) && (lastInfo->sampleSize == mi.frameLength))
lastInfo->samples += 1;
else {
lastInfo = &(*info)[*infoCount];
*infoCount += 1;
infoCountFree -= 1;
FskMemSet(lastInfo, 0, sizeof(FskMediaReaderSampleInfoRecord));
lastInfo->samples = 1;
lastInfo->sampleSize = mi.frameLength;
lastInfo->flags = kFskImageFrameTypeSync;
lastInfo->decodeTime = state->atTime;
lastInfo->sampleDuration = mi.samplesPerFrame;
lastInfo->compositionTime = -1;
}
FskMemMove(data, state->readBufferPtr, mi.frameLength);
data += mi.frameLength;
state->readBufferPtr += mi.frameLength;
spaceInOutput -= mi.frameLength;
state->atTime += mi.samplesPerFrame;
continue;
}
}
state->readBufferPtr += 1;
state->resync = true;
}
bail:
if (kFskErrNone != err) {
if ((kFskErrNeedMoreTime == err) || (kFskErrEndOfFile == err)) {
if (0 != *infoCount)
err = kFskErrNone;
}
if (kFskErrNone != err) {
FskMemPtrDisposeAt((void **)info);
FskMemPtrDisposeAt((void **)dataOut);
*infoCount = 0;
}
}
#if SUPPORT_MP3_LOG_TO_FILE
if (kFskErrNone == err) {
if (NULL == gFref) {
FskFileDelete("c:/dump.mp3");
FskFileCreate("c:/dump.mp3");
FskFileOpen("c:/dump.mp3", kFskFilePermissionReadWrite, &gFref);
}
FskFileWrite(gFref, outputSize - spaceInOutput, *dataOut, NULL);
}
#endif
return err;
}
static FskErr sFskNetInterfaceEnumerate(FskNetInterfaceRecord **interfaceList)
{
FskErr err = kFskErrNone;
FskNetInterfaceRecord *nir;
int fd;
struct ifreq ifr;
struct sockaddr_in *sa;
#if TARGET_OS_MAC // BSD
struct ifreq ibuf[32];
#endif /* TARGET_OS_MAC */
#if TARGET_OS_LINUX
#if TARGET_OS_ANDROID
DIR *d;
struct dirent *dir;
*interfaceList = NULL;
fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if (fd < 0) goto skip;
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "Enumerate Interfaces:");
d = opendir("/sys/class/net");
if (0 == d) {
BAIL(kFskErrNetworkInterfaceError);
}
while ((dir = readdir(d))) {
#if IGNORE_NETINTERFACE
Boolean ignore = false;
int i;
#endif
char *ifname;
unsigned theIP = 0, theNetmask = 0, theStatus = 0;
if (dir->d_name[0] == '.')
continue;
ifname = dir->d_name;
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation,"%s: ", ifname);
#if IGNORE_NETINTERFACE
i = NUM_IGNORE_NET;
while (i) {
if (FskStrCompare(ignoreInterfaces[i-1], ifname) == 0) {
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "IGNORED");
ignore = true;
}
i--;
}
if (ignore)
continue;
#endif /* IGNORE_NETINTERFACE */
memset(&ifr, 0, sizeof(struct ifreq));
strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
ifr.ifr_name[IFNAMSIZ - 1] = 0;
if (ioctl(fd, SIOCGIFADDR, &ifr) >= 0) {
sa = (struct sockaddr_in*)(void*)&(ifr.ifr_addr);
theIP = ntohl( sa->sin_addr.s_addr);
}
if (ioctl(fd, SIOCGIFNETMASK, &ifr) >= 0) {
sa = (struct sockaddr_in*)(void*)&(ifr.ifr_addr);
theNetmask = ntohl( sa->sin_addr.s_addr);
}
if (ioctl(fd, SIOCGIFFLAGS, &ifr) >= 0) {
if (ifr.ifr_flags & 1)
theStatus = 1;
}
if (theIP == 0)
theStatus = 0;
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation,"IP: %x, Netmask: %x [%s]", theIP, theNetmask, theStatus ? "UP " : "DOWN ");
if (ioctl(fd, SIOCGIFHWADDR, &ifr) >= 0) {
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "Got HWADDR ");
if (ifr.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, " ETHER");
FskMemPtrNewClear(sizeof(FskNetInterfaceRecord), (FskMemPtr*)(void*)&nir);
if (!nir) {
closedir(d);
BAIL(kFskErrMemFull);
}
FskMemCopy(nir->MAC, ifr.ifr_hwaddr.sa_data, 6);
nir->name = FskStrDoCopy(ifname);
nir->ip = theIP;
nir->netmask = theNetmask;
nir->status = theStatus;
FskListAppend((FskList*)interfaceList, nir);
}
else {
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, " Family not ETHER Huh?");
}
}
}
closedir(d);
skip:
#else /* !TARGET_OS_ANDROID */
FILE *fp;
char buf[256];
#if IGNORE_NETINTERFACE
Boolean ignore = false;
int i;
#endif
*interfaceList = NULL;
fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if (fd < 0) goto skip;
fp = fopen("/proc/net/dev", "r");
if (!fp) {
BAIL(kFskErrNetworkInterfaceError);
}
// ignore two lines
fgets(buf, sizeof(buf), fp);
fgets(buf, sizeof(buf), fp);
while (fgets(buf, sizeof(buf), fp)) {
char *ifname = strtok(buf, " :");
if (!ifname) continue;
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation,"%s: ", ifname);
#if IGNORE_NETINTERFACE
i = NUM_IGNORE_NET;
while (i) {
if (FskStrCompare(ignoreInterfaces[i-1], ifname) == 0) {
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "IGNORED");
ignore = true;
}
i--;
}
if (ignore)
continue;
#endif /* IGNORE_NETINTERFACE */
strcpy(ifr.ifr_name, ifname);
if ((ioctl(fd, SIOCGIFHWADDR, &ifr) != -1) && (ifr.ifr_hwaddr.sa_family == ARPHRD_ETHER)) {
FskMemPtrNewClear(sizeof(FskNetInterfaceRecord), (FskMemPtr *)&nir);
if (!nir) {
err = kFskErrMemFull;
fclose(fp);
goto bail;
}
FskMemCopy(nir->MAC, ifr.ifr_hwaddr.sa_data, 6);
nir->name = FskStrDoCopy(ifname);
nir->ip = 0;
if (ioctl(fd, SIOCGIFADDR, &ifr) != -1) {
sa = (struct sockaddr_in*)(void*)&(ifr.ifr_addr);
nir->ip = ntohl( sa->sin_addr.s_addr);
}
if (ioctl(fd, SIOCGIFNETMASK, &ifr) != -1) {
sa = (struct sockaddr_in*)(void*)&(ifr.ifr_addr);
nir->netmask = ntohl( sa->sin_addr.s_addr);
}
if (ioctl(fd, SIOCGIFFLAGS, &ifr) != -1) {
if (ifr.ifr_flags & IFF_UP) {
nir->status = 1;
} else {
nir->status = 0;
}
}
if (nir->ip == 0)
nir->status = 0;
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation,"IP: %x, Netmask: %x [%s] HWADDR [%02x:%02x:%02x:%02x:%02x:%02x]", theIP, theNetmask, theStatus ? "UP " : "DOWN ", nir->MAC[0], nir->MAC[1], nir->MAC[2], nir->MAC[3], nir->MAC[4], nir->MAC[5]);
FskListAppend((FskList*)interfaceList, nir);
}
else {
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, " Family not ETHER or no HWADDR");
}
}
fclose(fp);
skip:
#endif /* !TARGET_OS_ANDROID */
#elif TARGET_OS_MAC && !TARGET_OS_IPHONE
struct ifreq *ifrp, *ifend;
unsigned int r;
struct ifconf ifc;
#if IGNORE_NETINTERFACE
Boolean ignore = false;
int i;
#endif
*interfaceList = NULL;
fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
ifc.ifc_len = sizeof(ibuf);
ifc.ifc_buf = (caddr_t)ibuf;
if (ioctl(fd, SIOCGIFCONF, &ifc) == -1 ||
ifc.ifc_len < (int)sizeof(struct ifreq)) {
BAIL(kFskErrNetworkInterfaceError);
}
ifrp = ibuf;
ifend = (struct ifreq*)((char*)ibuf + ifc.ifc_len);
while (ifrp < ifend) {
if (ifrp->ifr_addr.sa_family == AF_LINK &&
((struct sockaddr_dl *)&ifrp->ifr_addr)->sdl_type == IFT_ETHER) {
err = FskMemPtrNewClear(sizeof(FskNetInterfaceRecord), (FskMemPtr *)&nir);
BAIL_IF_ERR(err);
nir->name = FskStrDoCopy(ifrp->ifr_name);
FskMemCopy((char*)nir->MAC, (char*)LLADDR((struct sockaddr_dl *)&ifrp->ifr_addr), 6);
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation,"%s: ", nir->name);
#if IGNORE_NETINTERFACE
i = NUM_IGNORE_NET;
ignore = false;
while (i) {
if (FskStrCompare(ignoreInterfaces[i-1], nir->name) == 0) {
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "IGNORED");
ignore = true;
}
i--;
}
if (ignore) {
FskMemPtrDispose(nir->name);
FskMemPtrDisposeAt(&nir);
goto nextOne;
}
#endif /* IGNORE_NETINTERFACE */
strcpy(ifr.ifr_name, nir->name); //@@ bounds check needed?
if (ioctl(fd, SIOCGIFADDR, &ifr) != -1) {
sa = (struct sockaddr_in*)(void*)&(ifr.ifr_addr);
nir->ip = ntohl( sa->sin_addr.s_addr);
}
if (nir->ip) {
if (ioctl(fd, SIOCGIFNETMASK, &ifr) != -1) {
sa = (struct sockaddr_in*)(void*)&(ifr.ifr_addr);
nir->netmask = ntohl( sa->sin_addr.s_addr);
}
if (ioctl(fd, SIOCGIFFLAGS, &ifr) != -1) {
if (ifr.ifr_flags & IFF_UP)
nir->status = 1;
}
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation,"IP: %x, Netmask: %x [%s] HWADDR [%02x:%02x:%02x:%02x:%02x:%02x]", nir->ip, nir->netmask, nir->status ? "UP " : "DOWN ", nir->MAC[0], nir->MAC[1], nir->MAC[2], nir->MAC[3], nir->MAC[4], nir->MAC[5]);
FskListAppend(interfaceList, nir);
}
else {
FskMemPtrDispose(nir->name);
FskMemPtrDisposeAt(&nir);
}
}
nextOne:
r = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
if (r < sizeof(*ifrp))
r = sizeof(*ifrp);
ifrp = (struct ifreq*)((char*)ifrp+r);
}
#elif TARGET_OS_IPHONE
struct ifaddrs *iflist;
if (getifaddrs(&iflist) != 0)
return kFskErrNetworkInterfaceError;
*interfaceList = NULL;
for (struct ifaddrs *ifa = iflist; ifa != NULL; ifa = ifa->ifa_next) {
if (ifa->ifa_name == NULL || ifa->ifa_addr == NULL || ifa->ifa_netmask == NULL || ((struct sockaddr_in*)(void*)ifa->ifa_addr)->sin_addr.s_addr == 0)
continue;
for (FskNetInterface ni = *interfaceList; ni != NULL; ni = ni->next) {
if (FskStrCompare(ni->name, ifa->ifa_name) == 0)
goto next;
}
if ((err = FskMemPtrNewClear(sizeof(FskNetInterfaceRecord), (FskMemPtr *)&nir)) != kFskErrNone)
return err;
nir->name = FskStrDoCopy(ifa->ifa_name);
nir->ip = ntohl(((struct sockaddr_in*)(void*)ifa->ifa_addr)->sin_addr.s_addr);
nir->netmask = ntohl(((struct sockaddr_in*)(void*)ifa->ifa_netmask)->sin_addr.s_addr);
nir->status = ifa->ifa_flags & IFF_UP ? 1 : 0;
FskListAppend((FskList *)interfaceList, nir);
next:;
}
freeifaddrs(iflist);
return kFskErrNone;
#endif /* TARGET_OS_IPHONE */
// add loop back I/F to total number of IP addresses
err = FskMemPtrNewClear(sizeof(FskNetInterfaceRecord), (FskMemPtr*)(void*)&nir);
if (kFskErrNone == err) {
nir->name = FskStrDoCopy("localhost");
nir->ip = FskNetMakeIP(127,0,0,1);
nir->netmask = 0xff000000;
nir->status = 1;
FskListAppend((FskList*)interfaceList, nir);
}
bail:
if (fd >= 0) // coverity 10587
close (fd);
return err;
}
void FskTextWindowsUninitialize(void)
{
FskExtensionUninstall(kFskExtensionTextEngine, &gFskTextWindowsDispatch);
FskMemPtrDisposeAt((void **)&gFontFamilyMap);
}
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;
#if TARGET_OS_ANDROID
char *toDirectory = NULL;
char* toPath = NULL;
FskFileInfo itemInfo;
FskFileMapping map = NULL;
unsigned char *data;
FskInt64 dataSize;
FskFile file = NULL;
#endif
err = FskTextEngineNew(&fte, NULL);
if (err) goto bail;
fromDirectory = FskEnvironmentDoApply(FskStrDoCopy(fontsPath));
if (!fromDirectory) { err = kFskErrMemFull; goto bail; }
#if TARGET_OS_ANDROID
if (!FskStrCompareWithLength(fromDirectory, "/data/app/", 10)) {
err = FskDirectoryGetSpecialPath(kFskDirectorySpecialTypeApplicationPreference, false, NULL, &toDirectory);
if (err) goto bail;
}
#endif
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; }
FskDebugStr("from %s", fromPath);
#if TARGET_OS_ANDROID
if (toDirectory) {
toPath = FskStrDoCat(toDirectory, name);
FskDebugStr("to %s", toPath);
if (kFskErrNone != FskFileGetFileInfo(toPath, &itemInfo)) {
err = FskFileMap(fromPath, &data, &dataSize, 0, &map);
if (err) goto bail;
err = FskFileCreate(toPath);
if (err) goto bail;
err = FskFileOpen(toPath, kFskFilePermissionReadWrite, &file);
if (err) goto bail;
err = FskFileWrite(file, dataSize, data, NULL);
if (err) goto bail;
FskFileClose(file);
file = NULL;
FskFileDisposeMap(map);
map = NULL;
}
FskDebugStr("add %s", toPath);
FskTextAddFontFile(fte, toPath);
FskMemPtrDisposeAt(&toPath);
}
else
#endif
FskTextAddFontFile(fte, fromPath);
FskMemPtrDisposeAt(&fromPath);
}
FskMemPtrDisposeAt(&name);
}
#if TARGET_OS_ANDROID
if (gAndroidCallbacks->getModelInfoCB) {
char* osVersion;
gAndroidCallbacks->getModelInfoCB(NULL, &osVersion, NULL, NULL, NULL);
if ((FskStrStr(osVersion, "android.5") == osVersion) // for KPR applications
|| (FskStrStr(osVersion, "5.") == osVersion)) { // for tests
BAIL_IF_ERR(err = FskFTAddMapping("/system/etc/fonts.xml"));
}
if ((FskStrStr(osVersion, "android.4") == osVersion) // for KPR applications
|| (FskStrStr(osVersion, "4.") == osVersion)) { // for tests
BAIL_IF_ERR(err = FskFTAddMapping("/system/etc/system_fonts.xml"));
err = FskFTAddMapping("/vendor/etc/fallback_fonts.xml");
if (err != kFskErrFileNotFound) BAIL(err);
BAIL_IF_ERR(err = FskFTAddMapping("/system/etc/fallback_fonts.xml"));
}
else {
defaultFont = "Droid Sans";
BAIL_IF_ERR(err = FskFTAddMapping(NULL));
}
}
#endif
if (defaultFont)
FskTextDefaultFontSet(fte, defaultFont);
bail:
#if TARGET_OS_ANDROID
if (file)
FskFileClose(file);
if (map)
FskFileDisposeMap(map);
FskMemPtrDispose(toPath);
FskMemPtrDispose(toDirectory);
#endif
FskMemPtrDispose(name);
FskDirectoryIteratorDispose(iterator);
FskMemPtrDispose(fromPath);
FskMemPtrDispose(fromDirectory);
FskTextEngineDispose(fte);
return err;
}
void fxIncludeScript(txParser* parser, txString string)
{
txBoolean done = 0;
char* base = NULL;
char name[PATH_MAX];
char* slash = NULL;
char* dot = NULL;
char* extension = NULL;
char* url = NULL;
char* path = NULL;
FskFileInfo fileInfo;
FskFileMapping map= NULL;
txFileMapStream fileMapStream;
txStringStream stringStream;
txMachine* the = parser->console;
fxBeginHost(the);
{
mxTry(the) {
xsThrowIfFskErr(KprPathToURL(parser->path->string, &base));
FskStrCopy(name, string);
slash = FskStrRChr(name, '/');
if (!slash)
slash = name;
dot = FskStrRChr(slash, '.');
if (dot)
extension = dot;
else
extension = name + FskStrLen(name);
if (!dot)
FskStrCopy(extension, ".js");
if (!FskStrCompare(extension, ".js")) {
xsThrowIfFskErr(KprURLMerge(base, name, &url));
xsThrowIfFskErr(KprURLToPath(url, &path));
if (kFskErrNone == FskFileGetFileInfo(path, &fileInfo)) {
xsThrowIfFskErr(FskFileMap(path, (unsigned char**)&(fileMapStream.buffer), &(fileMapStream.size), 0, &map));
fileMapStream.offset = 0;
fxIncludeTree(parser, &fileMapStream, fxFileMapGetter, parser->flags, path);
done = 1;
FskFileDisposeMap(map);
map = NULL;
}
FskMemPtrDisposeAt(&path);
FskMemPtrDisposeAt(&url);
}
if (!dot)
FskStrCopy(extension, ".xml");
if (!FskStrCompare(extension, ".xml")) {
xsThrowIfFskErr(KprURLMerge(base, name, &url));
xsThrowIfFskErr(KprURLToPath(url, &path));
if (kFskErrNone == FskFileGetFileInfo(path, &fileInfo)) {
xsThrowIfFskErr(FskFileMap(path, &fileMapStream.buffer, &fileMapStream.size, 0, &map));
fileMapStream.offset = 0;
mxPushInteger(0);
mxPushInteger(0);
mxPushInteger(0);
mxPushInteger(0);
mxPushInteger(3);
fxParse(the, &fileMapStream, fxFileMapGetter, path, 1, xsSourceFlag | xsDebugFlag);
fxCallID(the, fxID(the, "generate"));
fxToString(the, the->stack);
stringStream.slot = the->stack;
stringStream.size = c_strlen(stringStream.slot->value.string);
stringStream.offset = 0;
fxIncludeTree(parser, &stringStream, fxStringGetter, parser->flags, path);
done = 1;
FskFileDisposeMap(map);
map = NULL;
}
FskMemPtrDisposeAt(&path);
FskMemPtrDisposeAt(&url);
}
FskMemPtrDispose(base);
}
mxCatch(the) {
FskFileDisposeMap(map);
FskMemPtrDispose(path);
FskMemPtrDispose(url);
FskMemPtrDispose(base);
break;
}
}
fxEndHost(the);
if (!done)
fxReportParserError(parser, "include file not found: %s", string);
}
void KprStyleClearTextFont(KprStyle self)
{
FskMemPtrDisposeAt(&self->textFont);
self->flags &= ~kprTextFont;
KprStyleInvalidate(self);
}
void KprFILEServiceInvoke(KprService service UNUSED, KprMessage message)
{
FskErr err = kFskErrNone;
char* path = NULL;
FskFileInfo info;
FskDirectoryIterator iterator = NULL;
char* pathName = NULL;
char* sniff = NULL;
FskFile fref = NULL;
char *name = NULL;
if (KprMessageContinue(message)) {
if (!message->method || FskStrCompare(message->method, "GET")) {
bailIfError(KprURLToPath(message->url, &path));
bailIfError(FskFileGetFileInfo(path, &info));
if (kFskDirectoryItemIsDirectory == info.filetype) {
unsigned char buffer[4096];
UInt32 itemType;
double date;
UInt32 size;
xsBeginHostSandboxCode(gFILEService.machine, NULL);
{
xsVars(3);
{
xsTry {
xsVar(0) = xsGet(xsGlobal, xsID("Files"));
xsResult = xsNewInstanceOf(xsArrayPrototype);
bailIfError(FskDirectoryIteratorNew(path, &iterator, 0));
while (kFskErrNone == FskDirectoryIteratorGetNext(iterator, &name, &itemType)) {
if (name[0] == '.') {
FskMemPtrDisposeAt(&name);
continue;
}
if (kFskDirectoryItemIsFile == itemType) {
pathName = FskStrDoCat(path, name);
bailIfError(FskFileGetFileInfo(pathName, &info));
bailIfError(FskFileOpen(pathName, kFskFilePermissionReadOnly, &fref));
bailIfError(FskFileRead(fref, sizeof(buffer), buffer, &size));
FskFileClose(fref);
fref = NULL;
if (kFskErrNone == FskMediaPlayerSniffForMIME(buffer, size, NULL, pathName, &sniff)) {
}
else if (kFskErrNone == FskImageDecompressSniffForMIME(buffer, size, NULL, pathName, &sniff)) {
}
FskMemPtrDispose(pathName);
pathName = NULL;
}
xsVar(1) = xsNewInstanceOf(xsObjectPrototype);
xsNewHostProperty(xsVar(1), xsID("name"), xsString(name), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(1), xsID("path"), xsString(name), xsDefault, xsDontScript);
FskStrCopy((char*)buffer, message->url);
FskStrCat((char*)buffer, name);
if (kFskDirectoryItemIsDirectory == itemType) {
xsVar(2) = xsGet(xsVar(0), xsID("directoryType"));
FskStrCat((char*)buffer, "/");
}
else if (kFskDirectoryItemIsFile == itemType) {
xsVar(2) = xsGet(xsVar(0), xsID("fileType"));
if (info.fileModificationDate > info.fileCreationDate)
date = info.fileModificationDate * 1000.0;
else
date = info.fileCreationDate * 1000.0;
xsNewHostProperty(xsVar(1), xsID("date"), xsNumber(date), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(1), xsID("size"), xsNumber(info.filesize), xsDefault, xsDontScript);
if (sniff) {
xsNewHostProperty(xsVar(1), xsID("mime"), xsString(sniff), xsDefault, xsDontScript);
FskMemPtrDispose(sniff);
sniff = NULL;
}
}
else
xsVar(2) = xsGet(xsVar(0), xsID("linkType"));
xsNewHostProperty(xsVar(1), xsID("type"), xsVar(2), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(1), xsID("url"), xsString((char*)buffer), xsDefault, xsDontScript);
(void)xsCall1(xsResult, xsID("push"), xsVar(1));
FskMemPtrDisposeAt(&name);
}
xsResult = xsCall1(xsGet(xsGlobal, xsID("JSON")), xsID("stringify"), xsResult);
message->response.body = FskStrDoCopy(xsToString(xsResult));
message->response.size = FskStrLen(message->response.body);
KprMessageTransform(message, gFILEService.machine);
}
xsCatch {
}
}
}
xsEndHostSandboxCode();
}
else if (kFskDirectoryItemIsFile == info.filetype) {
// ------------------------------------------------------------------------
int FskHeadersParseChunk(char *blob, int blobSize, UInt16 headerType, FskHeaders *headers)
{
char *line = NULL;
int lineMax;
int copySize, lineSize;
char *blobPtr = blob, *pos;
int consumed = 0, leftoverSize = 0;
char *name, *value;
Boolean withComma;
int consumedSize = 0;
if (headers->headersParsed)
return 0;
if (headers->leftover) {
leftoverSize = FskStrLen(headers->leftover);
lineMax = blobSize + leftoverSize + 1;
if (kFskErrNone != FskMemPtrRealloc(lineMax, &line)) {
consumedSize = -1;
goto bail;
}
FskStrCopy(line, headers->leftover);
FskMemPtrDisposeAt((void**)(void*)&headers->leftover);
}
else {
lineMax = blobSize + 1;
if (kFskErrNone != FskMemPtrNew(lineMax, &line)) {
consumedSize = -1;
goto bail;
}
line[0] = '\0';
}
lineSize = FskStrLen(line);
while (blobPtr) {
copySize = blobSize;
pos = FskStrNChr(blobPtr, copySize, kFskLF);
if (pos) {
int i;
copySize = (pos - blobPtr) + 1;
for (i=0; i<copySize; i++) {
if (blobPtr[i] & 0x80) {
headers->headersParsed = true;
consumedSize = consumed - leftoverSize;
if (consumedSize == 0)
consumedSize = -1;
goto bail;
}
if (':' == blobPtr[i])
break; // high ascii allowed after the colon
}
}
FskStrNCopy(&line[lineSize], blobPtr, copySize);
line[lineSize+copySize] = '\0';
blobPtr += copySize;
blobSize -= copySize;
lineSize = FskStrLen(line);
if (((2 == lineSize) && (kFskCR == line[0]) && (kFskLF == line[1])) || ((1 == lineSize) && (kFskLF == line[0]))) { // the LF only case is to handle known bug with yimg.com (Yahoo Image server)
consumed += lineSize;
headers->headersParsed = true;
consumedSize = consumed - leftoverSize;
goto bail;
}
if (!pos) {
if (lineSize) {
headers->leftover = FskStrDoCopy(line);
consumed += lineSize;
}
consumedSize = consumed - leftoverSize;
goto bail;
}
consumed += lineSize;
if (NULL == headers->protocol) {
if ((-1 == sParseStartLine(line, headerType, headers) || (NULL == headers->protocol))) {
consumedSize = -1;
goto bail;
}
lineSize = 0;
line[0] = '\0';
continue;
}
withComma = true;
if (FskStrIsSpace(*line)) {
withComma = false;
name = headers->lastName;
value = line;
}
else {
name = FskStrStripHeadSpace(line);
value = FskStrChr(line, ':');
}
if (value) {
*value++ = '\0';
value = FskStrStripHeadSpace(value);
FskStrStripTailSpace(value);
}
if (NULL == name) {
consumedSize = -1;
goto bail;
}
FskStrStripTailSpace(name);
if (headers->flags & kFskHeadersDoNotMergeDuplicates) { // raw headers
FskAssociativeArrayNameList list;
SInt32 nameLen = FskStrLen(name) + 1;
SInt32 valueType = kFskStringType;
UInt32 valueSize = FskStrLen(value) + 1;
if (NULL == value) {
consumedSize = -1;
goto bail;
}
//bailIfError(FskMemPtrNew(sizeof(FskAssociativeArrayNameListRec) + nameLen + valueSize, &list));
if (kFskErrNone == FskMemPtrNew(sizeof(FskAssociativeArrayNameListRec) + nameLen + valueSize, &list)) {
unsigned char *d = list->data;
// name
FskMemMove(d, name, nameLen);
list->name = (char *)d;
d += nameLen;
// value
FskMemMove(d, value, valueSize);
list->value = (char *)d;
list->valueSize = valueSize;
list->valueType = valueType;
list->next = NULL;
FskListPrepend(headers->theHeaders, list);
}
}
else
FskAssociativeArrayElementCatenateString(headers->theHeaders, name, value, withComma);
if (name != headers->lastName) {
FskMemPtrDispose(headers->lastName);
headers->lastName = FskStrDoCopy(name);
}
line[0] = '\0';
lineSize = 0;
}
if (lineSize) {
headers->leftover = FskStrDoCopy(line);
consumed += lineSize;
}
consumedSize = consumed - leftoverSize;
bail:
if (line)
FskMemPtrDispose(line);
return consumedSize;
}
FskErr mp3RefillReadBuffer(mp3Reader state, UInt32 minimumBytesNeeded)
{
FskErr err = kFskErrNone;
UInt32 bytesInBuffer = (UInt32)(state->readBufferEnd - state->readBufferPtr);
UInt32 bytesRead;
void *buffer;
Boolean firstTime = true;
FskMemMove(state->readBuffer, state->readBufferPtr, bytesInBuffer);
state->readBufferPtr = state->readBuffer;
state->readBufferEnd = state->readBufferPtr + bytesInBuffer;
while (true) {
UInt32 bytesToRead = kMP3ReadBufferSize - bytesInBuffer;
if (state->spoolerSize && ((state->position + bytesToRead) > state->spoolerSize)) {
bytesToRead = (UInt32)(state->spoolerSize - state->position);
if (0 == bytesToRead) {
err = kFskErrEndOfFile;
goto bail;
}
}
if (0 != state->icy.metaInt) {
if (0 != state->icy.metaBytesToCollect) {
err = FskMediaSpoolerRead(state->spooler, state->position, state->icy.metaBytesToCollect, &buffer, &bytesRead);
if (kFskErrNone != err) goto readErr;
state->position += bytesRead;
err = FskMemPtrRealloc(state->icy.metaBytesCollected + bytesRead + 1, &state->icy.metaBytes);
if (err) return err;
FskMemMove(state->icy.metaBytes + state->icy.metaBytesCollected, buffer, bytesRead);
state->icy.metaBytes[state->icy.metaBytesCollected + bytesRead] = 0;
state->icy.metaBytesCollected += bytesRead;
state->icy.metaBytesToCollect -= bytesRead;
if (0 == state->icy.metaBytesToCollect) {
if (0 == FskStrCompareCaseInsensitiveWithLength((char *)state->icy.metaBytes, "StreamTitle=", 12)) {
char *start = (char *)state->icy.metaBytes + 13;
char *end = start;
char *dash;
FskMediaPropertyValueRecord prop;
while (true) {
end = FskStrChr(end, start[-1]);
if (NULL == end) break;
if ((0 != end[1]) && (';' != end[1])) {
end += 1;
continue;
}
break;
}
if (end)
*end = 0;
while (true) {
if (kFskErrNone != FskMediaMetaDataRemove(state->mi.meta, "FullName", 0))
break;
}
dash = FskStrStr(start, " - ");
if (NULL != dash) {
while (true) {
if (kFskErrNone != FskMediaMetaDataRemove(state->mi.meta, "Artist", 0))
break;
}
*dash = 0;
prop.type = kFskMediaPropertyTypeString;
prop.value.str = icyString(start);
FskMediaMetaDataAdd(state->mi.meta, "Artist", NULL, &prop, kFskMediaMetaDataFlagOwnIt);
prop.type = kFskMediaPropertyTypeString;
prop.value.str = icyString(dash + 3);
FskMediaMetaDataAdd(state->mi.meta, "FullName", NULL, &prop, kFskMediaMetaDataFlagOwnIt);
}
else {
prop.type = kFskMediaPropertyTypeString;
prop.value.str = icyString(start);
FskMediaMetaDataAdd(state->mi.meta, "FullName", NULL, &prop, kFskMediaMetaDataFlagOwnIt);
}
FskMediaReaderSendEvent(state->reader, kFskEventMediaPlayerMetaDataChanged);
}
FskMemPtrDisposeAt((void**)(void*)(&state->icy.metaBytes));
}
continue;
}
else
if (state->position == state->icy.nextMetaPosition) {
err = FskMediaSpoolerRead(state->spooler, state->position, 1, &buffer, &bytesRead);
if (kFskErrNone != err) goto readErr;
state->position += 1;
state->icy.metaBytesToCollect = ((unsigned char *)buffer)[0] * 16;
state->icy.metaBytesCollected = 0;
state->icy.nextMetaPosition += 1 + state->icy.metaBytesToCollect + state->icy.metaInt;
continue;
}
else
if ((state->position <= state->icy.nextMetaPosition) && (state->icy.nextMetaPosition < (state->position + bytesToRead)))
bytesToRead = (UInt32)(state->icy.nextMetaPosition - state->position);
}
err = FskMediaSpoolerRead(state->spooler, state->position, bytesToRead, &buffer, &bytesRead);
readErr:
if (err) {
if (false == firstTime) {
err = kFskErrNone;
break;
}
goto bail;
}
FskMemMove(state->readBufferEnd, buffer, bytesRead);
state->position += bytesRead;
state->readBufferEnd += bytesRead;
bytesInBuffer = (UInt32)(state->readBufferEnd - state->readBufferPtr);
if ((kMP3ReadBufferSize == bytesInBuffer) || (bytesInBuffer >= minimumBytesNeeded))
break;
firstTime = false;
}
if (bytesInBuffer < minimumBytesNeeded) {
err = kFskErrNeedMoreTime;
goto bail;
}
bail:
return err;
}
FskErr mp3Instantiate(mp3Reader state)
{
FskErr err = kFskErrNone;
FskInt64 totalSize;
if ((NULL != state->spooler->doGetSize) && (false == state->icy.isProtocol)) {
err = (state->spooler->doGetSize)(state->spooler, &totalSize);
if (err) goto bail;
}
else
totalSize = 0;
state->spoolerSize = totalSize;
state->mi.id3TagSize = 0;
state->mi.doExtendedParsing = 1;
if (false == scanMP3FromCallback(&state->mi, mp3ScanProc, state, totalSize, true)) {
if (0 != state->mi.id3TagSize) {
if (NULL == state->id3.data) {
state->id3.size = state->mi.id3TagSize;
err = FskMemPtrNew(state->id3.size, &state->id3.data);
if (err) goto bail;
} else if (state->id3.size < state->mi.id3TagSize) {
state->id3.size = state->mi.id3TagSize;
err = FskMemPtrRealloc(state->id3.size, &state->id3.data);
if (err) goto bail;
}
}
err = kFskErrBadData;
goto bail;
}
if (state->icy.isProtocol || state->icy.isNanocaster)
state->mi.duration = -1;
else if ((-1 == state->mi.duration) && (0 != state->dlnaDuration))
state->mi.duration = state->dlnaDuration;
if (NULL == state->mi.meta)
FskMediaMetaDataNew(&state->mi.meta); // so we can reliably have meta available for updates
if (NULL != state->icy.title) {
FskMediaPropertyValueRecord prop;
prop.type = kFskMediaPropertyTypeString;
prop.value.str = state->icy.title;
FskMediaMetaDataAdd(state->mi.meta, "FullName", NULL, &prop, 0);
}
if ((kFskAudioFormatMP3 == state->mi.codec) || (kFskAudioFormatMP2 == state->mi.codec) || (kFskAudioFormatMP1 == state->mi.codec) )
state->doHeaderParse = parseMP3Header;
else if (kFskAudioFormatAACADTS == state->mi.codec)
state->doHeaderParse = parseADTSHeader;
else {
err = kFskErrUnimplemented;
goto bail;
}
FskMemPtrDisposeAt(&state->id3.data);
(state->reader->doSetState)(state->reader, kFskMediaPlayerStateStopped);
bail:
return err;
}
FskErr FskSetAndroidCallbacks(FskAndroidCallbacks callbacks) {
// this is too early, if we call instrumentation here we will crash
// -- FskHardwarePrintfDebug("set android callbacks\n");
FskMemPtrDisposeAt(&gAndroidCallbacks);
return FskMemPtrNewFromData(sizeof(FskAndroidCallbacksRecord), callbacks, &gAndroidCallbacks);
}
void KprHTTPClientStart(KprService service, FskThread thread, xsMachine* the)
{
FskErr err = kFskErrNone;
char* cachePath = NULL;
char* preferencePath = NULL;
char* temp = NULL;
KprHTTPClient self = NULL;
UInt32 i, size;
KprHTTPConnection connection;
bailIfError(FskDirectoryGetSpecialPath(kFskDirectorySpecialTypeCache, true, NULL, &cachePath));
bailIfError(FskDirectoryGetSpecialPath(kFskDirectorySpecialTypeApplicationPreference, true, NULL, &preferencePath));
bailIfError(FskMemPtrNewClear(sizeof(KprHTTPClientRecord), &self));
FskInstrumentedItemNew(self, NULL, &KprHTTPClientInstrumentation);
gKprHTTPClient = self;
/* HTTP CACHE */
bailIfError(KprURLMerge(cachePath, "kpr.cache", &temp));
bailIfError(KprHTTPCacheNew(&self->cache,
KprEnvironmentGetUInt32("httpCacheSize", 197),
KprEnvironmentGetUInt32("httpCacheDiskSize", kprHTTPCacheDiskSize),
temp));
KprHTTPCacheRead(self->cache);
FskMemPtrDisposeAt(&temp);
/* COOKIES */
bailIfError(KprURLMerge(preferencePath, "kpr.cookies", &temp));
bailIfError(KprHTTPCookiesNew(&self->cookies, KprEnvironmentGetUInt32("httpCookiesSize", 197), temp));
KprHTTPCookiesRead(self->cookies);
FskMemPtrDisposeAt(&temp);
/* KEYCHAIN */
bailIfError(KprURLMerge(preferencePath, "kpr.keychain", &temp));
bailIfError(KprHTTPKeychainNew(&self->keychain, KprEnvironmentGetUInt32("httpKeychainSize", 197), temp));
KprHTTPKeychainRead(self->keychain);
FskMemPtrDisposeAt(&temp);
/* CONNECTIONS */
size = KprEnvironmentGetUInt32("httpPoolSize", 5);
for (i = 0; i < size; i++) {
bailIfError(KprHTTPConnectionNew(&connection));
FskInstrumentedItemSetOwner(connection, self);
connection->id = i;
FskListAppend(&self->connections, connection);
}
self->contentLength = KprEnvironmentGetUInt32("httpContentLength", 0x800000);
self->connectionTimeout = KprEnvironmentGetUInt32("httpConnectionTimeout", 0);
gHTTPService.machine = the;
gHTTPService.thread = thread;
gHTTPSService.machine = the;
gHTTPSService.thread = thread;
bail:
FskMemPtrDispose(temp);
FskMemPtrDispose(preferencePath);
FskMemPtrDispose(cachePath);
return;
}
