QString Api::getDefaultPatcherSecret(CancellationToken cancellationToken) const
{
qInfo() << "Getting the default patcher secret";
QString path = "1/system/patchers";
QJsonDocument document = get(path, cancellationToken);
if (!document.isArray())
{
throw InvalidFormatException("Expected document root to be array");
}
QJsonArray array = document.array();
QString platformString = Globals::currentPlatformString();
for (QJsonValueRef item : array)
{
if (item.isObject())
{
QJsonObject object = item.toObject();
if (object.contains(platformString))
{
return object[platformString].toString();
}
}
}
throw InvalidFormatException("Failed to resolve patcher for platform " + platformString);
}
void BgzfReader::seek(VirtualOffset offset) {
if((offset.getCoffset() == headerOffset) && (offset.getUoffset() >= (int)stream.total_out)) {
qint64 toSkip = offset.getUoffset() - stream.total_out;
if(skip(toSkip) < toSkip) {
coreLog.error(QString("in BgzfReader::seek, cannot seek to offset {coffset=%1,uoffset=%2}, failed to skip %3")
.arg(offset.getCoffset())
.arg(offset.getUoffset())
.arg(toSkip));
throw InvalidFormatException(BAMDbiPlugin::tr("Unexpected end of file"));
}
} else {
qint64 toSkipIo = offset.getCoffset() - ioAdapter.bytesRead();
if(!ioAdapter.skip(toSkipIo)) {
coreLog.error(QString("in BgzfReader::seek, cannot seek to offset {coffset=%1,uoffset=%2}, ioAdapter failed to skip %3")
.arg(offset.getCoffset())
.arg(offset.getUoffset())
.arg(toSkipIo));
throw IOException(BAMDbiPlugin::tr("Can't read input"));
}
stream.next_in = Z_NULL;
stream.avail_in = 0;
headerOffset = ioAdapter.bytesRead();
inflateReset(&stream);
qint64 toSkip = offset.getUoffset();
if(skip(toSkip) < toSkip) {
coreLog.error(QString("in BgzfReader::seek, cannot seek to offset {coffset=%1,uoffset=%2}, failed to skip %3 after ioAdapter skipped %4")
.arg(offset.getCoffset())
.arg(offset.getUoffset())
.arg(toSkip)
.arg(toSkipIo));
throw InvalidFormatException(BAMDbiPlugin::tr("Unexpected end of file"));
}
}
endOfFile = false;
}
QString Api::getPatcherSecret(const QString &appSecret, CancellationToken cancellationToken) const
{
qInfo() << "Getting the patcher secret for app " << appSecret;
auto path = QString("1/apps/%1")
.arg(appSecret);
QJsonDocument document = get(path, cancellationToken);
if (!document.isObject())
{
throw InvalidFormatException("Expected document root to be object");
}
if (!document.object().contains("patcher_secret"))
{
throw InvalidFormatException("Document did not contain the 'patcher_secret' field");
}
if (!document.object()["patcher_secret"].isString())
{
throw InvalidFormatException("patcher_secret was not a string");
}
return document.object()["patcher_secret"].toString();
}
int Api::getLatestAppVersion(const QString &appSecret, CancellationToken cancellationToken) const
{
qInfo() << "Getting the latest app version for app " << appSecret;
auto path = QString("1/apps/%1/versions/latest/id")
.arg(appSecret);
QJsonDocument document = get(path, cancellationToken);
if (!document.isObject())
{
throw InvalidFormatException("Expected document root to be object");
}
if (!document.object().contains("id"))
{
throw InvalidFormatException("Document did not contain the 'id' field");
}
if (!document.object()["id"].isDouble())
{
}
int id = document.object()["id"].toInt(-1);
if (id == -1)
{
throw InvalidFormatException("Value of 'id' field was not an integer");
}
return id;
}
void ParserModel::validateArtifactMap() throw(InvalidFormatException)
{
BaseModel::validateArtifactMap();
if (!(dynamic_cast<AbstractModel*>(artifactMap->get(BUILD_MODEL_ENTRY_NAME)) != 0))
{
throw InvalidFormatException("Missing the build model!");
}
ParserType modelType = getParserType();
if (modelType != 0)
{
if (CHUNKING::equals(modelType))
{
if (artifactMap->get(ATTACH_MODEL_ENTRY_NAME) != 0)
throw InvalidFormatException("attachModel must be null for chunking parser!");
}
else if (TREEINSERT::equals(modelType))
{
if (!(dynamic_cast<AbstractModel*>(artifactMap->get(ATTACH_MODEL_ENTRY_NAME)) != 0))
throw InvalidFormatException("attachModel must not be null!");
}
else
{
throw InvalidFormatException("Unkown ParserType!");
}
}
else
{
throw InvalidFormatException("Missing the parser type property!");
}
if (!(dynamic_cast<AbstractModel*>(artifactMap->get(CHECK_MODEL_ENTRY_NAME)) != 0))
{
throw InvalidFormatException("Missing the check model!");
}
if (!(dynamic_cast<POSModel*>(artifactMap->get(PARSER_TAGGER_MODEL_ENTRY_NAME)) != 0))
{
throw InvalidFormatException("Missing the tagger model!");
}
if (!(dynamic_cast<ChunkerModel*>(artifactMap->get(CHUNKER_TAGGER_MODEL_ENTRY_NAME)) != 0))
{
throw InvalidFormatException("Missing the chunker model!");
}
if (!(dynamic_cast<HeadRules*>(artifactMap->get(HEAD_RULES_MODEL_ENTRY_NAME)) != 0))
{
throw InvalidFormatException("Missing the head rules!");
}
}
unsigned int binary_to_uint(std::string s) {
if (s.size() == 0)
throw InvalidFormatException("Should at least one char, e.g. 0");
unsigned int sum = 0;
unsigned int mul = 1;
for (int i = s.size() - 1; i >= 0; --i) {
if (s[i] != '0' && s[i] != '1')
throw InvalidFormatException("binary literal should be 0 or 1");
sum += mul*char_to_uint(s[i]);
mul *= 2;
}
return sum;
}
unsigned int char_to_uint(char c) {
switch(c) {
case '0' : return 0;
case '1' : return 1;
case '2' : return 2;
case '3' : return 3;
case '4' : return 4;
case '5' : return 5;
case '6' : return 6;
case '7' : return 7;
case '8' : return 8;
case '9' : return 9;
case 'a' :
case 'A' :
return 10;
case 'b' :
case 'B' :
return 11;
case 'c' :
case 'C' :
return 12;
case 'd' :
case 'D' :
return 13;
case 'e' :
case 'E' :
return 14;
case 'f' :
case 'F' :
return 15;
default:
break;
}
throw InvalidFormatException("Character not one of the choices");
}
void BgzfReader::nextBlock() {
uInt oldAvailOut = stream.avail_out;
stream.avail_out = 0;
while(true) {
if(0 == stream.avail_in) {
qint64 returnedValue = ioAdapter.readBlock(buffer, sizeof(buffer));
if(-1 == returnedValue) {
coreLog.error(QString("in BgzfReader::nextBlock, failed to read %1 bytes from ioAdapter, after %2 bytes already read. %3")
.arg(sizeof(buffer))
.arg(ioAdapter.bytesRead())
.arg(ioAdapter.errorString()));
throw IOException(BAMDbiPlugin::tr("Can't read input"));
} else if(0 == returnedValue) {
endOfFile = true;
break;
} else {
stream.avail_in = returnedValue;
stream.next_in = (Bytef *)buffer;
}
}
int returnedValue = inflate(&stream, Z_SYNC_FLUSH);
if(Z_STREAM_END == returnedValue) {
headerOffset = ioAdapter.bytesRead() - stream.avail_in;
inflateReset(&stream);
} else if(Z_BUF_ERROR == returnedValue) {
break;
} else if(Z_OK != returnedValue) {
coreLog.error(QString("in BgzfReader::nextBlock, failed to decompress %1 bytes, after %2 raw bytes already read")
.arg(sizeof(buffer))
.arg(ioAdapter.bytesRead()));
throw InvalidFormatException(BAMDbiPlugin::tr("Can't decompress data"));
}
}
stream.avail_out = oldAvailOut;
}
bool RecordingDevice::start(int samples, int sampleRate, int bitDepth, int channels)
{
ALenum format = Audio::getFormat(bitDepth, channels);
if (format == AL_NONE)
throw InvalidFormatException(channels, bitDepth);
if (samples <= 0)
throw love::Exception("Invalid number of samples.");
if (sampleRate <= 0)
throw love::Exception("Invalid sample rate.");
if (isRecording())
stop();
device = alcCaptureOpenDevice(name.c_str(), sampleRate, format, samples);
if (device == nullptr)
return false;
alcCaptureStart(device);
this->samples = samples;
this->sampleRate = sampleRate;
this->bitDepth = bitDepth;
this->channels = channels;
return true;
}
QJsonDocument Api::get(const QString& path, CancellationToken cancellationToken) const
{
qInfo() << "Executing GET " << path;
ApiConnectionSettings connectionSettings = defaultConnectionSettings();
ApiConnectionStrategy strategy(connectionSettings, Config::minConnectionTimeoutMsec, Config::maxConnectionTimeoutMsec);
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
if (!strategy.execute(m_dataSource, path, buffer, cancellationToken))
{
throw ApiConnectionError("Failed to connect to the api.");
}
auto data = buffer.data();
QJsonParseError parseError;
auto doc = QJsonDocument::fromJson(data, &parseError);
if (parseError.error != QJsonParseError::NoError)
{
throw InvalidFormatException(parseError.errorString());
}
return doc;
}
unsigned int hex_to_uint(std::string s) {
if (s.size() == 0)
throw InvalidFormatException("Should at least one char, e.g. 0");
unsigned int sum = 0;
unsigned int mul = 1;
for (int i = s.size() - 1; i >= 0; --i) {
sum += mul*char_to_uint(s[i]);
mul *= 16;
}
return sum;
}
void TokenNameFinderModel::validateArtifactMap() throw(InvalidFormatException)
{
BaseModel::validateArtifactMap();
if (dynamic_cast<AbstractModel*>(artifactMap->get(MAXENT_MODEL_ENTRY_NAME)) != 0)
{
AbstractModel *model = static_cast<AbstractModel*>(artifactMap->get(MAXENT_MODEL_ENTRY_NAME));
isModelValid(model);
}
else
{
throw InvalidFormatException("Token Name Finder model is incomplete!");
}
}
QStringList Api::getContentUrls(const QString& appSecret, int versionId, CancellationToken cancellationToken) const
{
qInfo() << "Getting the content urls for app " << appSecret << " version " << versionId;
auto path = QString("1/apps/%1/versions/%2/content_urls")
.arg(appSecret).arg(versionId);
QJsonDocument document = get(path, cancellationToken);
QStringList contentUrls;
if (!document.isArray())
{
throw InvalidFormatException("Expected document root to be array");
}
auto arr = document.array();
for (auto item : arr)
{
if (!item.isObject())
{
throw InvalidFormatException("Expected array item to be object");
}
QJsonObject obj = item.toObject();
if (!obj.contains("url"))
{
throw InvalidFormatException("Did not contain the 'url' field");
}
contentUrls.push_back(obj["url"].toString());
}
return contentUrls;
}
qint64 BgzfReader::read(char *buff, qint64 maxSize) {
if(0 == maxSize) {
return 0;
}
stream.next_out = (Bytef *)buff;
stream.avail_out = maxSize;
while(stream.avail_out > 0) {
if(0 == stream.avail_in) {
qint64 returnedValue = ioAdapter.readBlock(buffer, sizeof(buffer));
if(-1 == returnedValue) {
coreLog.error(QString("in BgzfReader::read, failed to read %1 bytes from ioAdapter, after %2 bytes already read. %3")
.arg(sizeof(buffer))
.arg(ioAdapter.bytesRead())
.arg(ioAdapter.errorString()));
throw IOException(BAMDbiPlugin::tr("Can't read input"));
} else if(0 == returnedValue) {
endOfFile = true;
break;
} else {
stream.avail_in = returnedValue;
stream.next_in = (Bytef *)buffer;
}
}
int returnedValue = inflate(&stream, Z_SYNC_FLUSH);
if(Z_STREAM_END == returnedValue) {
nextBlock();
} else if(Z_OK != returnedValue) {
coreLog.error(QString("in BgzfReader::read, failed to decompress %1 bytes, after %2 raw bytes already read")
.arg(sizeof(buffer))
.arg(ioAdapter.bytesRead()));
throw InvalidFormatException(BAMDbiPlugin::tr("Can't decompress data"));
}
}
if(0 == stream.avail_in) {
nextBlock();
}
qint64 bytesRead = maxSize - stream.avail_out;
return bytesRead;
}
unsigned int uint_to_char(unsigned int val) {
switch(val) {
case 0 : return '0';
case 1 : return '1';
case 2 : return '2';
case 3 : return '3';
case 4 : return '4';
case 5 : return '5';
case 6 : return '6';
case 7 : return '7';
case 8 : return '8';
case 9 : return '9';
case 10 : return 'A';
case 11 : return 'B';
case 12 : return 'C';
case 13 : return 'D';
case 14 : return 'E';
case 15 : return 'F';
default : break;
}
throw InvalidFormatException("Overflow for input");
}
void PFPFile::load(FileObject &ff)
/*!\brief PFP-File laden
*
* Mit dieser Funktion wird ein PFP-File in die Klasse geladen. Dabei wird zuerst der Header geladen
* und überprüft, ob es sich um ein gültiges PFP-File handelt. Dann wird die virtuelle Funktion
* PFPFile::LoadRequest mit ID, Haupt- und Unterversion als Parameter aufgerufen. Liefert diese
* nicht true (1) zurück, wird der Ladevorgang abgebrochen. Andernfalls wird fortgeführt
* und geprüft, ob der
* Datenbereich komprimiert ist und gegebenenfalls dekomprimiert. Erst danach werden die
* einzelnen Chunks eingelesen. Kommt es dabei zu Fehlern durch ungültige Chunks, werden diese
* ignoriert und die Funktion gibt den Fehlercode 434 zurück.
*
* \param ff Pointer auf eine CFile-Klasse, mit der die einzulesende Datei geöffnet wurde.
* \returns Konnte die Datei fehlerfrei eingelesen werden, gibt die Funktion true (1) zurück,
* im Fehlerfall false (0). Ein entsprechender Fehlercode wird gesetzt.
*
* \remarks
* Vor dem Laden der Datei wird die Funktion PFPFile::Clear aufgerufen, so dass eventuell vorher
* vorhandene Daten verloren gehen.
*
* \since Version 6.1.0
*/
{
const char *p;
try {
p=ff.map(0,24);
} catch (OverflowException &) {
throw InvalidFormatException();
}
if (strncmp(p,"PFP-File",8)!=0) throw InvalidFormatException();
if (Peek8(p+8)!=3) throw InvalidFormatException();
size_t z,fsize;
// Wir haben ein gültiges PFP-File, aber dürfen wir es auch laden?
char tmpid[5];
tmpid[4]=0;
strncpy(tmpid,p+10,4);
int t1,t2;
t1=Peek8(p+15);
t2=Peek8(p+14);
if (!loadRequest(tmpid,t1,t2)) {
throw AccessDeniedByInstanceException();
}
clear();
id.set(p+10,4);
mainversion=Peek8(p+15);
subversion=Peek8(p+14);
comp=(Compression::Algorithm)Peek8(p+16);
size_t hsize=Peek8(p+9);
char *u=NULL;
if (comp) {
p=(char*)ff.map(hsize,8);
if (!p) throw ReadException();
size_t sizeunk=Peek32(p);
size_t sizecomp=Peek32(p+4);
p=ff.map(hsize+8,sizecomp);
if (!p) throw ReadException();
u=(char*)malloc(sizeunk+1);
if (!u) throw OutOfMemoryException();
size_t dstlen=sizeunk;
Compression c;
try {
c.init(comp);
c.uncompress(u,&dstlen,p,sizecomp);
} catch (...) {
free(u);
clear();
throw;
}
if (dstlen!=sizeunk) {
free(u);
clear();
throw DecompressionFailedException();
}
u[dstlen]=0;
p=u;
fsize=dstlen;
} else {
p=ff.map();
p+=hsize;
fsize=ff.size()-hsize;
}
// Wir haben nun den ersten Chunk ab Pointer p
z=0;
String Chunkname;
try {
size_t size=0;
while ((z+=size)<fsize) {
size=Peek32(p+z+4);
if (strncmp(p+z,"ENDF",4)==0) break;
if (!size) break;
// Falls z+size über das Ende der Datei geht, stimmt mit diesem Chunk was nicht
if (z+size>fsize) break;
PFPChunk *chunk=new PFPChunk;
if (!chunk) throw OutOfMemoryException();
Chunkname.set(p+z,4);
chunk->setName(Chunkname);
chunk->setData(p+z+8,size-8);
addChunk(chunk);
}
} catch (...) {
if (u) free(u);
clear();
throw;
}
if (u) free(u);
}
