void MojoWhereMatcher::ValidateClause(const MojObject& clause) const
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
LOG_AM_DEBUG("Validating where clause \"%s\"",
MojoObjectJson(clause).c_str());
if (!clause.contains(_T("prop"))) {
throw std::runtime_error("Each where clause must contain a property "
"to operate on");
}
MojObject prop;
clause.get(_T("prop"), prop);
ValidateKey(prop);
if (!clause.contains(_T("op"))) {
throw std::runtime_error("Each where clause must contain a test "
"operation to perform");
}
MojObject op;
clause.get(_T("op"), op);
ValidateOp(op);
if (!clause.contains(_T("val"))) {
throw std::runtime_error("Each where clause must contain a value to "
"test against");
}
}
void MojoWhereMatcher::ValidateClause(const MojObject& clause) const
{
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Validating where clause \"%s\""),
MojoObjectJson(clause).c_str());
if (!clause.contains(_T("prop"))) {
throw std::runtime_error("Each where clause must contain a property "
"to operate on");
}
MojObject prop;
clause.get(_T("prop"), prop);
ValidateKey(prop);
if (!clause.contains(_T("op"))) {
throw std::runtime_error("Each where clause must contain a test "
"operation to perform");
}
MojObject op;
clause.get(_T("op"), op);
ValidateOp(op);
if (!clause.contains(_T("val"))) {
throw std::runtime_error("Each where clause must contain a value to "
"test against");
}
}
bool LicenseSystem::LoadLicense()
{
ResetLicense();
FileSystem* filesystem = GetSubsystem<FileSystem>();
String licenseFilePath = filesystem->GetAppPreferencesDir("AtomicEditor", "License");
licenseFilePath = AddTrailingSlash(licenseFilePath);
licenseFilePath += "AtomicLicense";
if (!filesystem->FileExists(licenseFilePath))
return false;
SharedPtr<File> file(new File(context_, licenseFilePath, FILE_READ));
file->ReadInt(); // version
String key = file->ReadString();
if (!ValidateKey(key))
return false;
key_ = key;
licenseWindows_ = file->ReadBool();
licenseMac_ = file->ReadBool();
licenseAndroid_ = file->ReadBool();
licenseIOS_ = file->ReadBool();
licenseHTML5_ = file->ReadBool();
licenseModule3D_ = file->ReadBool();
return true;
}
static int TraditionalGenerate (TRI_key_generator_t* const generator,
const size_t maxLength,
const TRI_voc_tick_t tick,
const char* const userKey,
char* const outBuffer,
size_t* const outLength,
bool isRestore) {
traditional_keygen_t* data;
char* current;
data = (traditional_keygen_t*) generator->_data;
assert(data != NULL);
current = outBuffer;
if (userKey != NULL) {
size_t userKeyLength;
// user has specified a key
if (! data->_allowUserKeys && ! isRestore) {
// we do not allow user-generated keys
return TRI_ERROR_ARANGO_DOCUMENT_KEY_UNEXPECTED;
}
userKeyLength = strlen(userKey);
if (userKeyLength > maxLength) {
// user key is too long
return TRI_ERROR_ARANGO_DOCUMENT_KEY_BAD;
}
else if (userKeyLength == 0) {
// user key is empty
return TRI_ERROR_ARANGO_DOCUMENT_KEY_BAD;
}
// validate user-supplied key
if (! ValidateKey(userKey)) {
return TRI_ERROR_ARANGO_DOCUMENT_KEY_BAD;
}
memcpy(outBuffer, userKey, userKeyLength);
current += userKeyLength;
}
else {
// user has not specified a key, generate one based on tick
current += TRI_StringUInt64InPlace(tick, outBuffer);
}
// add 0 byte
*current = '\0';
if (current - outBuffer > (int) maxLength) {
return TRI_ERROR_ARANGO_DOCUMENT_KEY_BAD;
}
*outLength = (current - outBuffer);
return TRI_ERROR_NO_ERROR;
}
bool FileStorage::Validate() const
{
if (RequireKey())
{
return ValidateKey(Key());
}
return true;
}
char InputManager::GetUserInput() const
{
char keyPressed = CHAR_NOT_VALID;
if (_kbhit())
{
keyPressed = _getch();
ValidateKey(keyPressed);
}
return keyPressed;
}
//definition of class methods
void ConfigurableImpl::SetParameter( const uint64 & actualKey, eDataType type, const CombinedDataValue & value ) {
uint64 key = ModifyKey( actualKey );
if ( mTreatKeyAsCaseInsensitiveCharBuffer )
key = ConvertToLowerCase( key );
eConfigurableErrorCode validKey = ValidateKey( key );
eDataType oldType = kDTNone;
CombinedDataValue oldValue;
if ( validKey == kCECNone ) {
AutoSharedLock lock( GetMutex(), true );
if ( mKeysSet ) {
auto it = mKeysSet->find( key );
if ( it == mKeysSet->end() )
NotifyError( "Key is not supported", key, kCECKeyNotSupported, type, value, oldType, oldValue );
}
eConfigurableErrorCode validValue = ValidateValue( key, type, value );
if ( validValue == kCECNone && mKeyValueTypeMap ) {
auto it = mKeyValueTypeMap->find( key );
if ( it != mKeyValueTypeMap->end() ) {
if ( type != it->second ) {
validValue = kCECValueTypeNotSupported;
}
}
}
if ( validValue == kCECNone && !mAllowDifferentValueTypesForExistingEntries ) {
auto it = mMap.find( key );
if ( it != mMap.end() && it->second.first != type )
validValue = kCECPreviousTypeDifferent;
}
if ( validValue == kCECNone ) {
TypeValuePair pair;
pair.first = type;
pair.second = value;
mMap[ key ] = pair;
} else {
auto it = mMap.find( key );
if ( it != mMap.end() ) {
oldType = it->second.first;
oldValue = it->second.second;
}
NotifyError( "Validation failed for the parameter, type and value combination", key, validValue, type,
value, oldType, oldValue );
}
} else {
NotifyError( "Key is not valid", key, validKey, type, value, oldType, oldValue );
}
}
bool TRI_ValidateDocumentIdKeyGenerator (char const* key,
size_t* split) {
char const* p = key;
char c = *p;
// extract collection name
if (! (c == '_' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
return false;
}
++p;
while (1) {
c = *p;
if (c == '_' || c == '-' || (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
++p;
continue;
}
if (c == '/') {
break;
}
return false;
}
if (p - key > TRI_COL_NAME_LENGTH) {
return false;
}
// store split position
*split = p - key;
++p;
// validate document key
return ValidateKey(p);
}
void MojoNewWhereMatcher::ValidateClause(const MojObject& clause) const
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
LOG_AM_DEBUG("Validating where clause \"%s\"",
MojoObjectJson(clause).c_str());
bool found = false;
if (clause.contains(_T("and"))) {
found = true;
MojObject andClauses;
clause.get(_T("and"), andClauses);
ValidateClauses(andClauses);
}
if (clause.contains(_T("or"))) {
if (found) {
throw std::runtime_error("Only one of \"and\", \"or\", or a valid "
"clause including \"prop\", \"op\", and a \"val\"ue to "
"compare against must be present in a clause");
}
found = true;
MojObject orClauses;
clause.get(_T("or"), orClauses);
ValidateClauses(orClauses);
}
if (!clause.contains(_T("prop"))) {
if (!found) {
throw std::runtime_error("Each where clause must contain \"or\", "
"\"and\", or a \"prop\"erty to compare against");
} else {
return;
}
} else if (found) {
throw std::runtime_error("Only one of \"and\", \"or\", or a valid "
"clause including \"prop\", \"op\", and a \"val\"ue to "
"compare against must be present in a clause");
}
MojObject prop;
clause.get(_T("prop"), prop);
ValidateKey(prop);
if (!clause.contains(_T("val"))) {
throw std::runtime_error("Each where clause must contain a value to "
"test against");
}
MojObject val;
clause.get(_T("val"), val);
if (!clause.contains(_T("op"))) {
throw std::runtime_error("Each where clause must contain a test "
"operation to perform");
}
MojObject op;
clause.get(_T("op"), op);
ValidateOp(op, val);
}
bool TRI_ValidateKeyKeyGenerator (char const* key) {
return ValidateKey(key);
}
bool CSphConfigParser::Parse ( const char * sFileName, const char * pBuffer )
{
const int L_STEPBACK = 16;
const int L_TOKEN = 64;
const int L_BUFFER = 8192;
FILE * fp = NULL;
if ( !pBuffer )
{
// open file
fp = fopen ( sFileName, "rb" );
if ( !fp )
return false;
}
// init parser
m_sFileName = sFileName;
m_iLine = 0;
m_iWarnings = 0;
char * p = NULL;
char * pEnd = NULL;
char sBuf [ L_BUFFER ];
char sToken [ L_TOKEN ];
int iToken = 0;
int iCh = -1;
enum { S_TOP, S_SKIP2NL, S_TOK, S_TYPE, S_SEC, S_CHR, S_VALUE, S_SECNAME, S_SECBASE, S_KEY } eState = S_TOP, eStack[8];
int iStack = 0;
int iValue = 0, iValueMax = 65535;
char * sValue = new char [ iValueMax+1 ];
#define LOC_ERROR(_msg) { strncpy ( m_sError, _msg, sizeof(m_sError) ); break; }
#define LOC_ERROR2(_msg,_a) { snprintf ( m_sError, sizeof(m_sError), _msg, _a ); break; }
#define LOC_ERROR3(_msg,_a,_b) { snprintf ( m_sError, sizeof(m_sError), _msg, _a, _b ); break; }
#define LOC_ERROR4(_msg,_a,_b,_c) { snprintf ( m_sError, sizeof(m_sError), _msg, _a, _b, _c ); break; }
#define LOC_PUSH(_new) { assert ( iStack<int(sizeof(eStack)/sizeof(eState)) ); eStack[iStack++] = eState; eState = _new; }
#define LOC_POP() { assert ( iStack>0 ); eState = eStack[--iStack]; }
#define LOC_BACK() { p--; }
m_sError[0] = '\0';
for ( ; ; p++ )
{
// if this line is over, load next line
if ( p>=pEnd )
{
char * szResult = pBuffer ? GetBufferString ( sBuf, L_BUFFER, pBuffer ) : fgets ( sBuf, L_BUFFER, fp );
if ( !szResult )
break; // FIXME! check for read error
m_iLine++;
int iLen = strlen(sBuf);
if ( iLen<=0 )
LOC_ERROR ( "internal error; fgets() returned empty string" );
p = sBuf;
pEnd = sBuf + iLen;
if ( pEnd[-1]!='\n' )
{
if ( iLen==L_BUFFER-1 )
LOC_ERROR ( "line too long" );
}
}
// handle S_TOP state
if ( eState==S_TOP )
{
if ( isspace(*p) ) continue;
if ( *p=='#' )
{
#if !USE_WINDOWS
if ( !pBuffer && m_iLine==1 && p==sBuf && p[1]=='!' )
{
CSphVector<char> dResult;
if ( TryToExec ( p+2, pEnd, sFileName, dResult ) )
Parse ( sFileName, &dResult [0] );
break;
} else
#endif
{
LOC_PUSH ( S_SKIP2NL );
continue;
}
}
if ( !sphIsAlpha(*p) ) LOC_ERROR ( "invalid token" );
iToken = 0; LOC_PUSH ( S_TYPE ); LOC_PUSH ( S_TOK ); LOC_BACK(); continue;
}
// handle S_SKIP2NL state
if ( eState==S_SKIP2NL )
{
LOC_POP ();
p = pEnd;
continue;
}
// handle S_TOK state
if ( eState==S_TOK )
{
if ( !iToken && !sphIsAlpha(*p) )LOC_ERROR ( "internal error (non-alpha in S_TOK pos 0)" );
if ( iToken==sizeof(sToken) ) LOC_ERROR ( "token too long" );
if ( !sphIsAlpha(*p) ) { LOC_POP (); sToken [ iToken ] = '\0'; iToken = 0; LOC_BACK(); continue; }
if ( !iToken ) { sToken[0] = '\0'; }
sToken [ iToken++ ] = *p; continue;
}
// handle S_TYPE state
if ( eState==S_TYPE )
{
if ( isspace(*p) ) continue;
if ( *p=='#' ) { LOC_PUSH ( S_SKIP2NL ); continue; }
if ( !sToken[0] ) { LOC_ERROR ( "internal error (empty token in S_TYPE)" ); }
if ( IsPlainSection(sToken) ) { if ( !AddSection ( sToken, sToken ) ) break; sToken[0] = '\0'; LOC_POP (); LOC_PUSH ( S_SEC ); LOC_PUSH ( S_CHR ); iCh = '{'; LOC_BACK(); continue; }
if ( IsNamedSection(sToken) ) { m_sSectionType = sToken; sToken[0] = '\0'; LOC_POP (); LOC_PUSH ( S_SECNAME ); LOC_BACK(); continue; }
LOC_ERROR2 ( "invalid section type '%s'", sToken );
}
// handle S_CHR state
if ( eState==S_CHR )
{
if ( isspace(*p) ) continue;
if ( *p=='#' ) { LOC_PUSH ( S_SKIP2NL ); continue; }
if ( *p!=iCh ) LOC_ERROR3 ( "expected '%c', got '%c'", iCh, *p );
LOC_POP (); continue;
}
// handle S_SEC state
if ( eState==S_SEC )
{
if ( isspace(*p) ) continue;
if ( *p=='#' ) { LOC_PUSH ( S_SKIP2NL ); continue; }
if ( *p=='}' ) { LOC_POP (); continue; }
if ( sphIsAlpha(*p) ) { LOC_PUSH ( S_KEY ); LOC_PUSH ( S_TOK ); LOC_BACK(); iValue = 0; sValue[0] = '\0'; continue; }
LOC_ERROR2 ( "section contents: expected token, got '%c'", *p );
}
// handle S_KEY state
if ( eState==S_KEY )
{
// validate the key
if ( !ValidateKey ( sToken ) )
break;
// an assignment operator and a value must follow
LOC_POP (); LOC_PUSH ( S_VALUE ); LOC_PUSH ( S_CHR ); iCh = '=';
LOC_BACK(); // because we did not work the char at all
continue;
}
// handle S_VALUE state
if ( eState==S_VALUE )
{
if ( *p=='\n' ) { AddKey ( sToken, sValue ); iValue = 0; LOC_POP (); continue; }
if ( *p=='#' ) { AddKey ( sToken, sValue ); iValue = 0; LOC_POP (); LOC_PUSH ( S_SKIP2NL ); continue; }
if ( *p=='\\' )
{
// backslash at the line end: continuation operator; let the newline be unhanlded
if ( p[1]=='\r' || p[1]=='\n' ) { LOC_PUSH ( S_SKIP2NL ); continue; }
// backslash before number sign: comment start char escaping; advance and pass it
if ( p[1]=='#' ) { p++; }
// otherwise: just a char, pass it
}
if ( iValue<iValueMax ) { sValue[iValue++] = *p; sValue[iValue] = '\0'; }
continue;
}
// handle S_SECNAME state
if ( eState==S_SECNAME )
{
if ( isspace(*p) ) { continue; }
if ( !sToken[0]&&!sphIsAlpha(*p)){ LOC_ERROR2 ( "named section: expected name, got '%c'", *p ); }
if ( !sToken[0] ) { LOC_PUSH ( S_TOK ); LOC_BACK(); continue; }
if ( !AddSection ( m_sSectionType.cstr(), sToken ) ) break; sToken[0] = '\0';
if ( *p==':' ) { eState = S_SECBASE; continue; }
if ( *p=='{' ) { eState = S_SEC; continue; }
LOC_ERROR2 ( "named section: expected ':' or '{', got '%c'", *p );
}
// handle S_SECBASE state
if ( eState==S_SECBASE )
{
if ( isspace(*p) ) { continue; }
if ( !sToken[0]&&!sphIsAlpha(*p)){ LOC_ERROR2 ( "named section: expected parent name, got '%c'", *p ); }
if ( !sToken[0] ) { LOC_PUSH ( S_TOK ); LOC_BACK(); continue; }
// copy the section
assert ( m_tConf.Exists ( m_sSectionType ) );
if ( !m_tConf [ m_sSectionType ].Exists ( sToken ) )
LOC_ERROR4 ( "inherited section '%s': parent doesn't exist (parent name='%s', type='%s')",
m_sSectionName.cstr(), sToken, m_sSectionType.cstr() );
CSphConfigSection & tDest = m_tConf [ m_sSectionType ][ m_sSectionName ];
tDest = m_tConf [ m_sSectionType ][ sToken ];
// mark all values in the target section as "to be overridden"
tDest.IterateStart ();
while ( tDest.IterateNext() )
tDest.IterateGet().m_bTag = true;
LOC_BACK();
eState = S_SEC;
LOC_PUSH ( S_CHR );
iCh = '{';
continue;
}
LOC_ERROR2 ( "internal error (unhandled state %d)", eState );
}
#undef LOC_POP
#undef LOC_PUSH
#undef LOC_ERROR
if ( !pBuffer )
fclose ( fp );
SafeDeleteArray ( sValue );
if ( m_iWarnings>WARNS_THRESH )
fprintf ( stdout, "WARNING: %d more warnings skipped.\n", m_iWarnings-WARNS_THRESH );
if ( strlen(m_sError) )
{
int iCol = (int)(p-sBuf+1);
int iCtx = Min ( L_STEPBACK, iCol ); // error context is upto L_STEPBACK chars back, but never going to prev line
const char * sCtx = p-iCtx+1;
if ( sCtx<sBuf )
sCtx = sBuf;
char sStepback [ L_STEPBACK+1 ];
memcpy ( sStepback, sCtx, iCtx );
sStepback[iCtx] = '\0';
fprintf ( stdout, "ERROR: %s in %s line %d col %d.\n", m_sError, m_sFileName.cstr(), m_iLine, iCol );
return false;
}
return true;
}
