/* EXPORTED LUA FUNCTIONS */
int keyboardScript::lua_Wait(lua_State* L)
{
if (!verifyParameters(L, "lua_Wait", 1))
return 1;
auto time = keyboardScript::getIntegerParameter(L, 1);
Sleep(time);
lua_pushboolean(L, true);
return 1;
}
bool CEvaluationNodeCall::compile(const CEvaluationTree * pTree)
{
bool success = true;
clearParameters(mpCallParameters, mCallNodes);
switch (mType & 0x00FFFFFF)
{
case FUNCTION:
mpFunction =
dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
if (!mpFunction) return false;
// We need to check whether the provided arguments match the on needed by the
// function;
if (!verifyParameters(mCallNodes, mpFunction->getVariables())) return false;
mpCallParameters = buildParameters(mCallNodes);
break;
case EXPRESSION:
mpExpression =
dynamic_cast<CExpression *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
if (!mpExpression)
{
// We may have a function with no arguments the parser is not able to distinguish
// between that and an expression.
mpFunction =
dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
if (!mpFunction) return false;
mType = (CEvaluationNode::Type)(CEvaluationNode::CALL | FUNCTION);
success = compile(pTree);
}
else
{
success = mpExpression->compile(static_cast<const CExpression *>(pTree)->getListOfContainer());
}
break;
default:
success = false;
break;
}
return success;
}
// Client-side portion of work for server-relief mode. Return true if there are no memory
// allocation errors. The password and data are not cleared if there is an error.
bool TwoCats_ClientHashPassword(TwoCats_HashType hashType, uint8_t *hash, uint8_t *password,
uint32_t passwordSize, const uint8_t *salt, uint32_t saltSize, uint8_t *data,
uint32_t dataSize, uint8_t startMemCost, uint8_t stopMemCost, uint8_t timeCost,
uint8_t multiplies, uint8_t lanes, uint8_t parallelism, uint32_t blockSize,
uint32_t subBlockSize, uint8_t overwriteCost, bool clearPassword, bool clearData) {
TwoCats_H H;
TwoCats_InitHash(&H, hashType);
if(!verifyParameters(&H, startMemCost, stopMemCost, timeCost, multiplies, lanes,
parallelism, blockSize, subBlockSize)) {
return false;
}
// Convert overwiteCost from relative to startMemCost to absolute
if(overwriteCost >= startMemCost) {
overwriteCost = 0;
} else if(overwriteCost != 0) {
overwriteCost = startMemCost - overwriteCost;
}
// Add all the inputs, other than stopMemCost
uint32_t hash32[H.len];
if(!H.Init(&H) || !H.UpdateUint32(&H, passwordSize) ||
!H.UpdateUint32(&H, saltSize) || !H.UpdateUint32(&H, dataSize) ||
!H.UpdateUint32(&H, blockSize) || !H.UpdateUint32(&H, subBlockSize) ||
!H.Update(&H, &startMemCost, 1) || !H.Update(&H, &timeCost, 1) ||
!H.Update(&H, &multiplies, 1) || !H.Update(&H, &lanes, 1) ||
!H.Update(&H, ¶llelism, 1) || !H.Update(&H, &overwriteCost, 1) ||
!H.Update(&H, password, passwordSize) || !H.Update(&H, salt, saltSize) ||
!H.Update(&H, data, dataSize) || !H.FinalUint32(&H, hash32)) {
return false;
}
// Now clear the password and data if allowed
if(clearPassword && passwordSize != 0) {
secureZeroMemory(password, passwordSize);
}
if(clearData && dataSize != 0) {
secureZeroMemory(data, dataSize);
}
if(!TwoCats(&H, hash32, startMemCost, stopMemCost, timeCost, multiplies,
lanes, parallelism, blockSize, subBlockSize, overwriteCost)) {
return false;
}
encodeLittleEndian(hash, hash32, H.size);
secureZeroMemory(hash32, H.size);
return true;
}
int keyboardScript::lua_UpdateKeyboard(lua_State* L)
{
if (!verifyParameters(L, "lua_UpdateKeyboard", 0))
return 1;
if (this->keyboardInstance != nullptr)
{
this->keyboardInstance->updateKeyboard();
lua_pushboolean(L, true);
}
else
lua_pushboolean(L, false);
return 1;
}
// Update an existing password hash to a more difficult level of memory cost (garlic).
bool TwoCats_UpdatePassword(TwoCats_HashType hashType, uint8_t *hash, uint8_t oldMemCost,
uint8_t newMemCost, uint8_t timeCost, uint8_t multiplies, uint8_t lanes,
uint8_t parallelism, uint32_t blockSize, uint32_t subBlockSize) {
TwoCats_H H;
TwoCats_InitHash(&H, hashType);
if(!verifyParameters(&H, oldMemCost, newMemCost, timeCost, multiplies, lanes,
parallelism, blockSize, subBlockSize)) {
return false;
}
uint32_t hash32[H.len];
decodeLittleEndian(hash32, hash, H.size);
if(!TwoCats(&H, hash32, oldMemCost, newMemCost, timeCost, multiplies, lanes,
parallelism, blockSize, subBlockSize, 0)) {
return false;
}
encodeLittleEndian(hash, hash32, H.size);
return TwoCats_ServerHashPassword(hashType, hash);
}
int keyboardScript::lua_SetKeyColor(lua_State* L)
{
if (!verifyParameters(L, "lua_SetKeyColor", 4))
return 1;
auto key = keyboardScript::getIntegerParameter(L, 1);
auto r = keyboardScript::getIntegerParameter(L, 2);
auto g = keyboardScript::getIntegerParameter(L, 3);
auto b = keyboardScript::getIntegerParameter(L, 4);
if (this->keyboardInstance != nullptr)
{
auto ret = this->keyboardInstance->setKey((uint8_t)key, (uint8_t)r, (uint8_t)g, (uint8_t)b);
lua_pushboolean(L, ret);
}
else
lua_pushboolean(L, false);
return 1;
}
int keyboardScript::lua_InitializeKeyboard(lua_State* L)
{
if (!verifyParameters(L, "lua_InitializeKeyboard", 1))
return 1;
auto type = keyboardScript::getIntegerParameter(L, 1);
switch (type)
{
case KEYBOARD_K70:
this->keyboardInstance = std::shared_ptr<corsairRGBKeyboard>(new corsairRGBKeyboardK70());
break;
case KEYBOARD_K95:
this->keyboardInstance = std::shared_ptr<corsairRGBKeyboard>(new corsairRGBKeyboardK95());
break;
default:
break;
}
lua_pushboolean(L, this->keyboardInstance != nullptr && this->keyboardInstance->isValid());
return 1;
}
void ctkPluginGeneratorAbstractExtension::validate()
{
Q_D(ctkPluginGeneratorAbstractExtension);
d->valid = verifyParameters(d->parameters);
}
bool CEvaluationNodeCall::compile(const CEvaluationTree * pTree)
{
bool success = true;
clearParameters(mpCallParameters, mCallNodes);
CObjectInterface * pObjectInterface = NULL;
if (mRegisteredFunctionCN != "")
{
pObjectInterface = const_cast< CObjectInterface * >(CCopasiRootContainer::getRoot()->getObject(mRegisteredFunctionCN));
}
switch (mSubType)
{
case S_FUNCTION:
if (pObjectInterface != NULL)
{
mpFunction = dynamic_cast< CFunction * >(pObjectInterface);
}
else
{
mpFunction =
dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
}
if (!mpFunction) return false;
mRegisteredFunctionCN = mpFunction->getCN();
// We need to check whether the provided arguments match the on needed by the
// function;
if (!verifyParameters(mCallNodes, mpFunction->getVariables())) return false;
mpCallParameters = buildParameters(mCallNodes);
break;
case S_EXPRESSION:
if (pObjectInterface != NULL)
{
mpExpression = dynamic_cast<CExpression *>(pObjectInterface);
}
else
{
mpExpression =
dynamic_cast<CExpression *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
}
if (!mpExpression)
{
// We may have a function with no arguments the parser is not able to distinguish
// between that and an expression.
if (pObjectInterface != NULL)
{
mpFunction = dynamic_cast< CFunction * >(pObjectInterface);
}
else
{
mpFunction =
dynamic_cast<CFunction *>(CCopasiRootContainer::getFunctionList()->findFunction(mData));
}
if (!mpFunction) return false;
mRegisteredFunctionCN = mpFunction->getCN();
mMainType = T_CALL;
mSubType = S_FUNCTION;
success = compile(pTree);
}
else
{
mRegisteredFunctionCN = mpExpression->getCN();
success = mpExpression->compile(static_cast<const CExpression *>(pTree)->getListOfContainer());
}
break;
default:
success = false;
break;
}
return success;
}
