/*
============
idCVarSystemLocal::GetCVarFloat
============
*/
float idCVarSystemLocal::GetCVarFloat( const char *name ) const {
idInternalCVar *internal = FindInternal( name );
if ( internal ) {
return internal->GetFloat();
}
return 0.0f;
}
/*
============
idCVarSystemLocal::GetCVarBool
============
*/
bool idCVarSystemLocal::GetCVarBool( const char *name ) const {
idInternalCVar *internal = FindInternal( name );
if ( internal ) {
return internal->GetBool();
}
return false;
}
/*
============
idCVarSystemLocal::GetCVarInteger
============
*/
int idCVarSystemLocal::GetCVarInteger( const char *name ) const {
idInternalCVar *internal = FindInternal( name );
if ( internal ) {
return internal->GetInteger();
}
return 0;
}
//---------------------------------------------------------------------------
const std::vector<int> ManyDigitIndexTable::FindInternal(
const std::vector<int>& indices,
const MultiVector<int>& v,
const int value)
{
//Check indices
{
const auto begin = v.PeekIndices().begin();
const auto end = v.PeekIndices().end();
const auto x = std::find(begin,end,value);
if (x!=end)
{
const int index_found = std::distance(begin,x);
assert(index_found >= 0);
assert(index_found < boost::numeric_cast<int>(v.PeekIndices().size()));
std::vector<int> result = indices;
result.push_back(index_found);
return result;
}
}
//Check MultiVector
const auto& mvs = v.PeekMultiVectors();
const int size = mvs.size();
for (int i=0; i!=size; ++i)
{
std::vector<int> indices_deeper = indices;
indices_deeper.push_back(i);
const auto result
= FindInternal(
indices_deeper,mvs[i],value);
if (!result.empty()) return result;
}
return std::vector<int>();
}
/*
============
idCVarSystemLocal::GetCVarString
============
*/
const char *idCVarSystemLocal::GetCVarString( const char *name ) const {
idInternalCVar *internal = FindInternal( name );
if ( internal ) {
return internal->GetString();
}
return "";
}
/*
============
idCVarSystemLocal::Command
============
*/
bool idCVarSystemLocal::Command( const idCmdArgs &args )
{
idInternalCVar *internal;
internal = FindInternal( args.Argv( 0 ) );
if ( internal == NULL )
{
return false;
}
if ( args.Argc() == 1 )
{
// print the variable
common->Printf( "\"%s\" is:\"%s\"" S_COLOR_WHITE " default:\"%s\"\n",
internal->nameString.c_str(), internal->valueString.c_str(), internal->resetString.c_str() );
if ( idStr::Length( internal->GetDescription() ) > 0 )
{
common->Printf( S_COLOR_WHITE "%s\n", internal->GetDescription() );
}
}
else
{
// set the value
internal->Set( args.Args(), false, false );
}
return true;
}
/*
============
idCVarSystemLocal::SetCVarsFromDict
============
*/
void idCVarSystemLocal::SetCVarsFromDict( const idDict &dict ) {
idInternalCVar *internal;
for( int i = 0; i < dict.GetNumKeyVals(); i++ ) {
const idKeyValue *kv = dict.GetKeyVal( i );
internal = FindInternal( kv->GetKey() );
if ( internal ) {
internal->InternalServerSetString( kv->GetValue() );
}
}
}
bool
OCSPCache::Get(const CertID& aCertID, Result& aResult, Time& aValidThrough)
{
MutexAutoLock lock(mMutex);
size_t index;
if (!FindInternal(aCertID, index, lock)) {
LogWithCertID("OCSPCache::Get(%p) not in cache", aCertID);
return false;
}
LogWithCertID("OCSPCache::Get(%p) in cache", aCertID);
aResult = mEntries[index]->mResult;
aValidThrough = mEntries[index]->mValidThrough;
MakeMostRecentlyUsed(index, lock);
return true;
}
/*
============
idCVarSystemLocal::SetInternal
============
*/
void idCVarSystemLocal::SetInternal( const char *name, const char *value, int flags ) {
int hash;
idInternalCVar *internal;
internal = FindInternal( name );
if ( internal ) {
internal->InternalSetString( value );
internal->flags |= flags & ~CVAR_STATIC;
internal->UpdateCheat();
} else {
internal = new idInternalCVar( name, value, flags );
hash = cvarHash.GenerateKey( internal->nameString.c_str(), false );
cvarHash.Add( hash, cvars.Append( internal ) );
}
}
/*
============
idCVarSystemLocal::Register
============
*/
void idCVarSystemLocal::Register( idCVar *cvar ) {
int hash;
idInternalCVar *internal;
cvar->SetInternalVar( cvar );
internal = FindInternal( cvar->GetName() );
if ( internal ) {
internal->Update( cvar );
} else {
internal = new idInternalCVar( cvar );
hash = cvarHash.GenerateKey( internal->nameString.c_str(), false );
cvarHash.Add( hash, cvars.Append( internal ) );
}
cvar->SetInternalVar( internal );
}
//---------------------------------------------------------------------------
///Find returns the x-y-coordinats of the Newick with index i
///This is a linear (in this case, relatively time-intensive) method.
const ManyDigitNewickCoordinat ManyDigitIndexTable::Find(
const int value) const
{
//Check indices
{
const auto begin = m_v.PeekIndices().begin();
const auto end = m_v.PeekIndices().end();
const auto x = std::find(begin,end,value);
if (x!=end)
{
const int index_found = std::distance(begin,x);
assert(index_found >= 0);
assert(index_found < boost::numeric_cast<int>(m_v.PeekIndices().size()));
return Coordinat( { index_found } );
}
}
//Check MultiVector
const std::vector<MultiVector<int> >& mvs
= m_v.PeekMultiVectors();
const int size = mvs.size();
for (int i=0; i!=size; ++i)
{
const auto result
= FindInternal(
std::vector<int>(1,i),
mvs[i],
value);
if (!result.empty())
{
return Coordinat(result);
}
}
assert(!"Should not get here");
std::stringstream s;
s << "Value " << value << " not found in ManyDigitIndexTable::Find";
throw std::logic_error(s.str());
}
bool
OCSPCache::Get(const CERTCertificate* aCert,
const CERTCertificate* aIssuerCert,
PRErrorCode& aErrorCode,
PRTime& aValidThrough)
{
PR_ASSERT(aCert);
PR_ASSERT(aIssuerCert);
MutexAutoLock lock(mMutex);
size_t index;
if (!FindInternal(aCert, aIssuerCert, index, lock)) {
LogWithCerts("OCSPCache::Get(%s, %s) not in cache", aCert, aIssuerCert);
return false;
}
LogWithCerts("OCSPCache::Get(%s, %s) in cache", aCert, aIssuerCert);
aErrorCode = mEntries[index]->mErrorCode;
aValidThrough = mEntries[index]->mValidThrough;
MakeMostRecentlyUsed(index, lock);
return true;
}
Result
OCSPCache::Put(const CertID& aCertID, Result aResult,
Time aThisUpdate, Time aValidThrough)
{
MutexAutoLock lock(mMutex);
size_t index;
if (FindInternal(aCertID, index, lock)) {
// Never replace an entry indicating a revoked certificate.
if (mEntries[index]->mResult == Result::ERROR_REVOKED_CERTIFICATE) {
LogWithCertID("OCSPCache::Put(%p) already in cache as revoked - "
"not replacing", aCertID);
MakeMostRecentlyUsed(index, lock);
return Success;
}
// Never replace a newer entry with an older one unless the older entry
// indicates a revoked certificate, which we want to remember.
if (mEntries[index]->mThisUpdate > aThisUpdate &&
aResult != Result::ERROR_REVOKED_CERTIFICATE) {
LogWithCertID("OCSPCache::Put(%p) already in cache with more recent "
"validity - not replacing", aCertID);
MakeMostRecentlyUsed(index, lock);
return Success;
}
// Only known good responses or responses indicating an unknown
// or revoked certificate should replace previously known responses.
if (aResult != Success &&
aResult != Result::ERROR_OCSP_UNKNOWN_CERT &&
aResult != Result::ERROR_REVOKED_CERTIFICATE) {
LogWithCertID("OCSPCache::Put(%p) already in cache - not replacing "
"with less important status", aCertID);
MakeMostRecentlyUsed(index, lock);
return Success;
}
LogWithCertID("OCSPCache::Put(%p) already in cache - replacing", aCertID);
mEntries[index]->mResult = aResult;
mEntries[index]->mThisUpdate = aThisUpdate;
mEntries[index]->mValidThrough = aValidThrough;
MakeMostRecentlyUsed(index, lock);
return Success;
}
if (mEntries.length() == MaxEntries) {
LogWithCertID("OCSPCache::Put(%p) too full - evicting an entry", aCertID);
for (Entry** toEvict = mEntries.begin(); toEvict != mEntries.end();
toEvict++) {
// Never evict an entry that indicates a revoked or unknokwn certificate,
// because revoked responses are more security-critical to remember.
if ((*toEvict)->mResult != Result::ERROR_REVOKED_CERTIFICATE &&
(*toEvict)->mResult != Result::ERROR_OCSP_UNKNOWN_CERT) {
delete *toEvict;
mEntries.erase(toEvict);
break;
}
}
// Well, we tried, but apparently everything is revoked or unknown.
// We don't want to remove a cached revoked or unknown response. If we're
// trying to insert a good response, we can just return "successfully"
// without doing so. This means we'll lose some speed, but it's not a
// security issue. If we're trying to insert a revoked or unknown response,
// we can't. We should return with an error that causes the current
// verification to fail.
if (mEntries.length() == MaxEntries) {
return aResult;
}
}
Entry* newEntry = new (std::nothrow) Entry(aResult, aThisUpdate,
aValidThrough);
// Normally we don't have to do this in Gecko, because OOM is fatal.
// However, if we want to embed this in another project, OOM might not
// be fatal, so handle this case.
if (!newEntry) {
return Result::FATAL_ERROR_NO_MEMORY;
}
Result rv = newEntry->Init(aCertID);
if (rv != Success) {
delete newEntry;
return rv;
}
if (!mEntries.append(newEntry)) {
delete newEntry;
return Result::FATAL_ERROR_NO_MEMORY;
}
LogWithCertID("OCSPCache::Put(%p) added to cache", aCertID);
return Success;
}
/*
============
idCVarSystemLocal::Find
============
*/
idCVar *idCVarSystemLocal::Find( const char *name ) {
return FindInternal( name );
}
int main(int argc, char **argv) {
if (argc < 3) {
PrintUsage(stderr, argv[0]);
return -1;
}
if (!strcmp(argv[1], "create")) {
if (argc < 4) {
fprintf(stderr, "ERROR: incorrect create usage\n");
return -2;
}
char *outbfile = argv[2];
int n = atoi(argv[3]);
/* Calculate btree size */
int depth = CalcMinimumDepth(n);
int sz = CalcTreeSize2(n, depth);
fprintf(stderr, "n = %i, depth = %i, size = %i\n", n, depth, sz);
/* Create memory buffer */
mem = (char *) malloc(sz + 1);
mem[sz] = 123; // Magic Marker to detect overflow
memSize = sz;
/* Init top node */
BlockAddrT top = AllocBlock(0x0);
Node topNode;
NodeInit(&topNode);
topNode.depth = depth - 1; // total depth vs depth(rank?) of this node
NodeSave(&topNode, top);
BgTree tree;
tree.topNode = top;
/* Read in data */
KeyT highestKey = 0;
for (int i=0; i<n; i++) {
KeyT key;
BlockAddrT item;
int res = fscanf(stdin, "%x\t%x", &key, &item);
assert(res == 2);
if (key < highestKey) {
fprintf(stderr, "ERROR: Key out of order on line %i. Input must be sorted!\n", i+1);
return -3;
}
highestKey = key;
//printf("GOT %i %i\n", key, item);
TreeAppend(tree, key, item);
}
/* Set keys for non-leaf nodes */
//NodeVisitDFS(&SetKeysVisitor, top);
/* Write memory to file */
assert(mem[sz] == 123);
fprintf(stderr, "MEM: %i of %i allocated was used\n", memLast, memSize);
FILE *f = fopen(outbfile, "wb");
if (!f) {
fprintf(stderr, "ERROR: Failed to open file %s for writing\n", outbfile);
return -9;
}
int res = fwrite(mem, 1, memLast, f);
if (res != memLast) {
fprintf(stderr, "ERROR: Could not write all data to file %s\n", outbfile);
return -4;
}
fclose(f);
} // end of "create" command
if (!strcmp(argv[1], "search")) {
if (argc < 4) {
fprintf(stderr, "ERROR: search usage incorrect, not enough arguments\n");
return -11;
}
FILE *blobfile = 0x0;
if (argc > 4) {
blobfile = fopen(argv[4],"rb");
if (!blobfile) {
fprintf(stderr, "ERROR: failed to open Blob File %s\n", argv[4]);
return -19;
}
}
char *schema=0x0;
if (argc > 5) {
schema = argv[5];
}
char *inbfile = argv[2];
KeyT key;
int res;
if (argv[3][0] == 'S') {
key = CalcCRC(&argv[3][1], strlen(&argv[3][1]));
//fprintf(stderr, "CRC32=%x for %s len=%i\n", key, &argv[3][1], (int) strlen(&argv[3][1]));
printf("%x", key);
if (mem)
free(mem);
exit(0);
} else { // assume hex
res = sscanf(argv[3], "%x", &key);
if (res != 1) {
fprintf(stderr, "ERROR: Unable to parse query key argument %s\n", argv[3]);
return -12;
}
}
if (LoadBGT(inbfile) != 0)
return -99;
/* Perform Search */
BAT outParent;
int outIndex;
BAT found_temp;
BAT found = FindInternal(0, key, &outParent, &outIndex);
while (found != BAInvalid) {
// if (found == BAInvalid) {
// printf("%x NOT FOUND!\n", key);
// } else {
//printf("%x\t%08x", key, found);
if (schema && blobfile) {
for (char *p = &schema[0]; *p; ++p) {
if ((*p == 's') || (*p == 'K')) {
char buf[2000000];
fseek(blobfile, found, SEEK_SET);
int sz = UnpackStringFromFile(blobfile, buf, 2000000);
if (sz < 0) {
fprintf(stderr, "ERROR: Failed to read String from blob file\n");
return -20;
}
found += sz;
buf[sz] = 0x0; // not null terminated by default
printf("\t%s", buf);
} else if (*p == 'i') {
int32_t v;
fseek(blobfile, found, SEEK_SET);
v = UnpackIntFromFile(blobfile);
ERRORassert();
found += 4;
//printf("\t%i", v);
} else if ((*p == 'I') || (*p == 'x') || (*p == 'X')) {
uint32_t v;
fseek(blobfile, found, SEEK_SET);
v = UnpackUIntFromFile(blobfile);
ERRORassert();
//if (*p == 'I')
// printf("\t%u", v);
//else
// printf("\t%x", v);
found += 4;
} else {
fprintf(stderr, "ERROR: Unsupported schema character '%c'\n", *p);
return -23;
}
}
}
printf("\n");
// found_temp = NodeNextLeaf(NodeParent(found), found);
//found_temp = FindInternal(0, key, &outParent, &outIndex);
key++;
found_temp = FindInternal(0, key, &outParent, &outIndex);
found = found_temp;
}
if (blobfile)
fclose(blobfile);
} else if (!strcmp(argv[1],"printtree")) {
if (LoadBGT(argv[2]) != 0) {
printf("Error Loading BGT\n");
return -99;
}
BgTree dummy;
TreeInit(&dummy,0x0);
NodeVisitDFS(dummy, &PrintVisitor, 0);
}
if (mem)
free(mem);
}
