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 FskCopyFile(char *src, char *dst) { char buf[4096]; UInt32 amt, amtWrt; int doit=0; FskFileInfo info, infoSrc; FskFile srcFref = NULL, dstFref = NULL; FskErr err = kFskErrNone; if (kFskErrFileNotFound == FskFileGetFileInfo(dst, &info)) { FskAndroidFilesPrintfDebug("dst: %s not found\n", dst); doit = 1; } else if (kFskErrNone == FskFileGetFileInfo(src, &infoSrc)) { if (infoSrc.filesize != info.filesize) { FskAndroidFilesPrintfDebug("src size: %d, dstSize: %d\n", infoSrc.filesize, info.filesize); doit = 1; } } if (doit) { FskAndroidFilesPrintfDebug("Need to copy it over.\n"); err = FskFileOpen(src, kFskFilePermissionReadOnly, &srcFref); BAIL_IF_ERR(err); err = FskFileCreate(dst); BAIL_IF_ERR(err); err = FskFileOpen(dst, kFskFilePermissionReadWrite, &dstFref); BAIL_IF_ERR(err); while (kFskErrNone == err) { err = FskFileRead(srcFref, 4096, buf, &amt); BAIL_IF_ERR(err); if (0 >= amt) break; while (amt) { err = FskFileWrite(dstFref, amt, buf, &amtWrt); BAIL_IF_ERR(err); amt -= amtWrt; } } err = FskFileClose(dstFref); BAIL_IF_ERR(err); dstFref = NULL; err = FskFileClose(srcFref); BAIL_IF_ERR(err); srcFref = NULL; } bail: if(kFskErrEndOfFile == err){ err = kFskErrNone; } if(dstFref) FskFileClose(dstFref); if(srcFref) FskFileClose(srcFref); return err; }
FskErr KprSoundLoadSpoolerRead(FskMediaSpooler spooler, FskInt64 position, UInt32 bytesToRead, void **buffer, UInt32 *bytesRead) { FskErr err = kFskErrNone; KprSoundLoadSpoolerRefcon refcon = spooler->refcon; bailIfError(FskFileSetPosition(refcon->fref, &position)); bailIfError(FskFileRead(refcon->fref, (bytesToRead > sizeof(refcon->buffer)) ? sizeof(refcon->buffer) : bytesToRead, refcon->buffer, bytesRead)); *buffer = refcon->buffer; bail: return err; }
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); }
FskErr fxLoadModuleJSBAtom(txMachine* the, FskFile fref, Atom* atom) { FskErr err = kFskErrNone; char buffer[sizeof(Atom)]; void* p = buffer; bailIfError(FskFileRead(fref, sizeof(Atom), p, NULL)); mxDecode4(p, atom->atomSize); mxDecode4(p, atom->atomType); bail: return err; }
void unpackAndroid() { char * src, *dst, buf[4096]; int doit=0; UInt32 amt, amtWrt; FskFileInfo info, infoSrc; FskFile srcFref, dstFref; FskErr err; dst = FskStrDoCat(gAndroidCallbacks->getStaticDataDirCB(), "ca-bundle.crt"); src = FskStrDoCat(gAndroidCallbacks->getStaticAppDirCB(), "/res/raw/kinoma.jet/ca-bundle.crt"); if (kFskErrFileNotFound == FskFileGetFileInfo(dst, &info)) { fprintf(stderr, "dst: %s not found\n", dst); doit = 1; } else if (kFskErrNone == FskFileGetFileInfo(src, &infoSrc)) { if (infoSrc.filesize != info.filesize) { fprintf(stderr, "src size: %lld, dstSize: %lld\n", infoSrc.filesize, info.filesize); doit = 1; } } if (doit) { fprintf(stderr, "Need to copy it over.\n"); err = FskFileOpen(src, kFskFilePermissionReadOnly, &srcFref); if (err) fprintf(stderr, "open %s failed %d\n", src, err); err = FskFileCreate(dst); if (err) fprintf(stderr, "create %s failed %d\n", dst, err); err = FskFileOpen(dst, kFskFilePermissionReadWrite, &dstFref); if (err) fprintf(stderr, "open %s failed %d\n", dst, err); while (kFskErrNone == err) { err = FskFileRead(srcFref, 4096, buf, &amt); if (err) fprintf(stderr, "read %s (%lu bytes) failed %d\n", src, amt, err); if (0 >= amt) break; while (amt) { err = FskFileWrite(dstFref, amt, buf, &amtWrt); if (err) fprintf(stderr, "write %s (%lu bytes) failed %d\n", dst, amt, err); amt -= amtWrt; } } err = FskFileClose(dstFref); if (err) fprintf(stderr, "close %s failed %d\n", src, err); err = FskFileClose(srcFref); if (err) fprintf(stderr, "close %s failed %d\n", src, err); } FskMemPtrDispose(src); FskMemPtrDispose(dst); }
FskErr KprDBExecuteFile(KprDB self, char* path) { FskErr err = kFskErrNone; FskFileInfo info; FskFile fref = NULL; char *buffer = NULL;; bailIfError(FskFileGetFileInfo(path, &info)); bailIfError(KprMemPtrNew(info.filesize + 1, &buffer)); bailIfError(FskFileOpen(path, kFskFilePermissionReadOnly, &fref)); bailIfError(FskFileRead(fref, info.filesize, buffer, NULL)); buffer[info.filesize] = 0; sqlite3_exec(self->data, buffer, NULL, NULL, NULL); bail: KprMemPtrDispose(buffer); FskFileClose(fref); return err; }
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) {
message->response.size = FskStrLen(message->response.body); KprMessageTransform(message, gFILEService.machine); } xsCatch { } } } xsEndHostSandboxCode(); } else if (kFskDirectoryItemIsFile == info.filetype) { KprStream stream = message->stream; FskInt64 size; bailIfError(FskFileOpen(path, kFskFilePermissionReadOnly, &fref)); bailIfError(FskFileGetSize(fref, &size)); bailIfError(FskMemPtrNew(size, &message->response.body)); bailIfError(FskFileRead(fref, size, message->response.body, &message->response.size)); if (stream && stream->dispatch->receive) { (*stream->dispatch->receive)(stream, message, gFILEService.machine, message->response.body, message->response.size); FskMemPtrDisposeAt(&message->response.body); message->response.size = 0; } KprMessageTransform(message, gFILEService.machine); } else err = kFskErrUnimplemented; } else err = kFskErrUnimplemented; bail: FskMemPtrDispose(sniff); FskFileClose(fref);
FskErr KprSoundLoad(KprSound self) { FskErr err = kFskErrNone; char *path = NULL; FskFile fref = NULL; FskMediaSpoolerRecord spooler; KprSoundLoadSpoolerRefconRecord refcon; FskMediaReader reader = NULL; FskMediaReaderTrack track; FskMediaPropertyValueRecord property; char *audioFormat = NULL; double duration; unsigned char *formatInfo = NULL; UInt32 formatInfoSize; UInt16 numChannels; double sampleRate; double timeScale; FskMediaReaderSampleInfo info = NULL; unsigned char *buffer = NULL; KprSoundFrame frames = NULL; UInt32 frameCount = 0; unsigned char *data = NULL; UInt32 dataSize = 0; if (self->data) goto bail; bailIfError(KprURLToPath(self->url, &path)); if (!self->mime) { unsigned char buffer[4096]; UInt32 size; char *sniff = NULL; bailIfError(FskFileOpen(path, kFskFilePermissionReadOnly, &fref)); bailIfError(FskFileRead(fref, sizeof(buffer), buffer, &size)); FskFileClose(fref); fref = NULL; bailIfError(FskMediaPlayerSniffForMIME(buffer, size, NULL, self->url, &sniff)); self->mime = sniff; } FskMemSet(&spooler, 0, sizeof(spooler)); FskMemSet(&refcon, 0, sizeof(refcon)); refcon.path = path; spooler.refcon = &refcon; spooler.doOpen = KprSoundLoadSpoolerOpen; spooler.doClose = KprSoundLoadSpoolerClose; spooler.doRead = KprSoundLoadSpoolerRead; spooler.doGetSize = KprSoundLoadSpoolerGetSize; bailIfError((*FskMediaReaderNewProc)(&reader, self->mime, self->url, &spooler, NULL, NULL)); bailIfError((*FskMediaReaderGetPropertyProc)(reader, kFskMediaPropertyTimeScale, &property)); timeScale = property.value.integer; (*FskMediaReaderGetPropertyProc)(reader, kFskMediaPropertyDuration, &property); duration = property.value.number; (*FskMediaReaderGetTrackProc)(reader, 0, &track); (*FskMediaReaderTrackGetPropertyProc)(track, kFskMediaPropertyFormat, &property); audioFormat = property.value.str; if (kFskErrNone == (*FskMediaReaderTrackGetPropertyProc)(track, kFskMediaPropertyFormatInfo, &property)) { formatInfo = property.value.data.data; formatInfoSize = property.value.data.dataSize; } else formatInfoSize = 0; (*FskMediaReaderTrackGetPropertyProc)(track, kFskMediaPropertyChannelCount, &property); numChannels = property.value.integer; (*FskMediaReaderTrackGetPropertyProc)(track, kFskMediaPropertySampleRate, &property); sampleRate = property.value.integer; bailIfError((*FskMediaReaderStartProc)(reader, NULL, NULL)); for (;;) { UInt32 c = 0, i, s; unsigned char *d; err = (*FskMediaReaderExtractProc)(reader, &track, &c, &info, &buffer); if (err == kFskErrEndOfFile) { err = kFskErrNone; break; } if (err != kFskErrNone) goto bail; for (i = 0, d = buffer; i < c; i++, d += s) { s = info[i].sampleSize * info[i].samples; bailIfError(FskMemPtrRealloc((frameCount + 1) * sizeof(KprSoundFrameRecord), &frames)); frames[frameCount].count = info[i].samples; frames[frameCount].frameSize = info[i].sampleSize; frames[frameCount].samplesPerFrame = info[i].sampleDuration; frames[frameCount].frameOffset = dataSize; frameCount++; bailIfError(FskMemPtrRealloc(dataSize + s, &data)); FskMemCopy(data + dataSize, d, s); dataSize += s; } FskMemPtrDispose(buffer); buffer = NULL; FskMemPtrDispose(info); info = NULL; } (*FskMediaReaderStopProc)(reader); self->audioFormat = audioFormat; self->duration = duration; self->formatInfo = formatInfo; self->formatInfoSize = formatInfoSize; self->numChannels = numChannels; self->sampleRate = sampleRate; self->timeScale = timeScale; self->data = data; self->dataSize = dataSize; self->frames = frames; self->frameCount = frameCount; bail: if (err) { FskMemPtrDispose(data); FskMemPtrDispose(frames); FskMemPtrDispose(formatInfo); FskMemPtrDispose(audioFormat); } FskMemPtrDispose(buffer); FskMemPtrDispose(info); (*FskMediaReaderDisposeProc)(reader); FskFileClose(fref); FskMemPtrDispose(path); return err; }