DAL::DataSet* SQLite::ExecuteQuery(const char* SqlStatement)
{
SQLite::SQLiteDataSet* returnValue = new SQLite::SQLiteDataSet();
Logger::GetInstance().Debug("SQLite::ExecuteQuery", SqlStatement);
try
{
char* error = NULL;
if (sqlite3_exec(this->database, SqlStatement, SQLite::ExecuteCallback, returnValue, &error) != SQLITE_OK)
{
std::string errorMsg = "SQLite::ExecuteQuery FATAL: Could not execute " + std::string(SqlStatement) + " : " + std::string(error);
sqlite3_free(error);
throw WarningException("SQLite::ExecuteQuery", errorMsg, HERE);
}
}
catch (WarningException& e)
{
throw WarningException(e, HERE);
}
catch (std::exception &e)
{
throw FatalException("DAL::ExecuteQuery", e.what(), HERE);
}
catch (...)
{
throw FatalException("DAL::ExecuteQuery", "Unspecified exception while executing an sql query.", HERE);
}
return returnValue;
}
//-----------------------------------------------------------------------------
// Square()
// Constructor
// ClusterType type - the type to be used to define the cluster
// Square *squares[9] - An array of nine squares to define the cluster
Cluster::Cluster(ClusterType type, Square *squares[9])
{
int k = 0;
for (k = 0; k < 9; k++)
references[k] = 0; //tracks what numbers are used
//------------------------------------------------
// Check to see if **squares are null
//------------------------------------------------
if (!squares)
{
throw FatalException("Cluster::Cluster() null pointer in parameter");
}
cluster_type = type;
//------------------------------------------------
// Initialize the squares using the provided array
//------------------------------------------------
for (k = 0; k < 9; k++)
{
if (!squares[k])
{
throw FatalException("Cluster::Cluster() null pointer in parameter");
}
cluster_group[k] = squares[k];
}
for (k = 0; k < 9; k++)
cluster_group[k]->addCluster(this);
referenceCount++;
}
void ZipFile::Work_AfterReadFile(uv_work_t* req) {
HandleScope scope;
closure_t *closure = static_cast<closure_t *>(req->data);
TryCatch try_catch;
if (closure->error) {
Local<Value> argv[1] = { Exception::Error(String::New(closure->error_name.c_str())) };
closure->cb->Call(Context::GetCurrent()->Global(), 1, argv);
} else {
node::Buffer *retbuf = Buffer::New(reinterpret_cast<char *>(&closure->data[0]), closure->data.size());
Local<Value> argv[2] = { Local<Value>::New(Null()), Local<Value>::New(retbuf->handle_) };
closure->cb->Call(Context::GetCurrent()->Global(), 2, argv);
}
if (try_catch.HasCaught()) {
FatalException(try_catch);
}
closure->zf->Unref();
uv_unref(uv_default_loop());
closure->cb.Dispose();
delete closure;
}
/**
* @details This is set by `FromFileAsync` to run after `FromFileWork` has
* finished. It is passed the response generated by the latter and runs in the
* same thread as the former. It creates a `Map` instance and returns it
* to the caller via the callback they originally specified.
*
* @param req The asynchronous libuv request.
*/
void Map::FromFileAfter(uv_work_t *req) {
HandleScope scope;
MapfileBaton *baton = static_cast<MapfileBaton*>(req->data);
Handle<Value> argv[2];
if (baton->error) {
argv[0] = baton->error->toV8Error();
argv[1] = Undefined();
delete baton->error; // we've finished with it
} else {
Local<Value> mapObj = External::New(baton->map);
Persistent<Object> map = Persistent<Object>(map_template->GetFunction()->NewInstance(1, &mapObj));
argv[0] = Undefined();
argv[1] = scope.Close(map);
}
// pass the results to the user specified callback function
TryCatch try_catch;
baton->callback->Call(Context::GetCurrent()->Global(), 2, argv);
if (try_catch.HasCaught()) {
FatalException(try_catch);
}
// clean up
baton->callback.Dispose();
delete baton;
return;
}
void Image::EIO_AfterComposite(uv_work_t* req)
{
HandleScope scope;
composite_image_baton_t *closure = static_cast<composite_image_baton_t *>(req->data);
TryCatch try_catch;
if (closure->error) {
Local<Value> argv[1] = { Exception::Error(String::New(closure->error_name.c_str())) };
closure->cb->Call(Context::GetCurrent()->Global(), 1, argv);
} else {
Local<Value> argv[2] = { Local<Value>::New(Null()), Local<Value>::New(closure->im1->handle_) };
closure->cb->Call(Context::GetCurrent()->Global(), 2, argv);
}
if (try_catch.HasCaught()) {
FatalException(try_catch);
}
closure->im1->Unref();
closure->im2->Unref();
closure->cb.Dispose();
delete closure;
}
void MSMap::DrawMapAfter(uv_work_t *req) {
HandleScope scope;
// drawmap_baton *drawmap_req =(drawmap_baton *)req->data;
drawmap_baton *baton = static_cast<drawmap_baton *>(req->data);
baton->map->Unref();
TryCatch try_catch;
Local<Value> argv[2];
if (baton->data != NULL) {
Buffer * buffer = Buffer::New(baton->data, baton->size, FreeImageBuffer, NULL);
argv[0] = Local<Value>::New(Null());
argv[1] = Local<Value>::New(buffer->handle_);
} else {
Local<Value> _arg_ = External::New(baton->error);
// argv[0] = Local<Value>::New(ErrorObj::constructor_template->GetFunction()->NewInstance(1, &_arg_));
errorObj * err = msGetErrorObj();
argv[0] = Local<Value>::New(MSError::New(err));
argv[1] = Local<Value>::New(Null());
}
baton->cb->Call(Context::GetCurrent()->Global(), 2, argv);
if (try_catch.HasCaught()) {
FatalException(try_catch);
}
baton->cb.Dispose();
delete baton;
return;
}
int Zipper::EIO_AfterAddFile(eio_req *req)
{
HandleScope scope;
closure_t *closure = static_cast<closure_t *>(req->data);
ev_unref(EV_DEFAULT_UC);
TryCatch try_catch;
if (closure->error) {
Local<Value> argv[1] = { Exception::Error(String::New(closure->error_name.c_str())) };
closure->cb->Call(Context::GetCurrent()->Global(), 1, argv);
} else {
Local<Value> argv[1] = { Local<Value>::New(Null()) };
closure->cb->Call(Context::GetCurrent()->Global(), 1, argv);
}
if (try_catch.HasCaught()) {
FatalException(try_catch);
//try_catch.ReThrow();
}
closure->zf->Unref();
closure->cb.Dispose();
delete closure;
return 0;
}
void ImageView::EIO_AfterEncode(uv_work_t* req)
{
HandleScope scope;
encode_image_baton_t *closure = static_cast<encode_image_baton_t *>(req->data);
TryCatch try_catch;
if (closure->error) {
Local<Value> argv[1] = { Exception::Error(String::New(closure->error_name.c_str())) };
closure->cb->Call(Context::GetCurrent()->Global(), 1, argv);
} else {
#if NODE_VERSION_AT_LEAST(0,3,0)
node::Buffer *retbuf = Buffer::New((char*)closure->result.data(),closure->result.size());
#else
node::Buffer *retbuf = Buffer::New(closure->result.size());
memcpy(retbuf->data(), closure->result.data(), closure->result.size());
#endif
Local<Value> argv[2] = { Local<Value>::New(Null()), Local<Value>::New(retbuf->handle_) };
closure->cb->Call(Context::GetCurrent()->Global(), 2, argv);
}
if (try_catch.HasCaught()) {
FatalException(try_catch);
}
//uv_unref(uv_default_loop());
closure->im->Unref();
closure->cb.Dispose();
delete closure;
}
void SQLite::Open(std::string Location)
{
if (sqlite3_open(Location.c_str(), &this->database))
{
std::string errorMsg = "Database::Database FATAL: Could not create database: " + std::string(sqlite3_errmsg(this->database));
throw FatalException("SQLite::Open", errorMsg, HERE);
}
this->ExecuteNonQuery("PRAGMA foreign_keys = ON");
}
void Grid::EIO_AfterEncode(uv_work_t* req)
{
HandleScope scope;
encode_grid_baton_t *closure = static_cast<encode_grid_baton_t *>(req->data);
TryCatch try_catch;
if (closure->error) {
Local<Value> argv[1] = { Exception::Error(String::New(closure->error_name.c_str())) };
closure->cb->Call(Context::GetCurrent()->Global(), 1, argv);
} else {
// convert key order to proper javascript array
Local<Array> keys_a = Array::New(closure->key_order.size());
std::vector<std::string>::iterator it;
unsigned int i;
for (it = closure->key_order.begin(), i = 0; it < closure->key_order.end(); ++it, ++i)
{
keys_a->Set(i, String::New((*it).c_str()));
}
mapnik::grid const& grid_type = *closure->g->get();
// gather feature data
Local<Object> feature_data = Object::New();
if (closure->add_features) {
node_mapnik::write_features<mapnik::grid>(grid_type,
feature_data,
closure->key_order);
}
// Create the return hash.
Local<Object> json = Object::New();
Local<Array> grid_array = Array::New(closure->lines.size());
unsigned array_size = static_cast<unsigned int>(grid_type.width()/closure->resolution);
for (unsigned j=0;j<closure->lines.size();++j)
{
grid_array->Set(j,String::New(&closure->lines[j],array_size));
}
json->Set(String::NewSymbol("grid"), grid_array);
json->Set(String::NewSymbol("keys"), keys_a);
json->Set(String::NewSymbol("data"), feature_data);
Local<Value> argv[2] = { Local<Value>::New(Null()), Local<Value>::New(json) };
closure->cb->Call(Context::GetCurrent()->Global(), 2, argv);
}
if (try_catch.HasCaught()) {
FatalException(try_catch);
}
uv_unref(uv_default_loop());
closure->g->Unref();
closure->cb.Dispose();
delete closure;
}
void PlayerComponent::setQtQuickWindow(QQuickWindow* window)
{
PlayerQuickItem* video = window->findChild<PlayerQuickItem*>("video");
if (!video)
throw FatalException(tr("Failed to load video element."));
mpv_set_option_string(m_mpv, "vo", "opengl-cb");
video->initMpv(this);
}
//-----------------------------------------------------------------------------
// getSquare()
// returns the square at the specified index
Square* Cluster::getSquare(int index)
{
if(index<0 || index>8)
{
string s = "Cluster::getSquare() index out of bounds ";
s+=index;
throw FatalException(s);
}
return cluster_group[index];
}
//-----------------------------------------------------------------------------
// isReferenced()
// returns true if the cluster references the specified value
bool Cluster::isReferenced(int n)
{
// I use a fatal exception because
// this method should never be called
// outside the scope of Marking a value
if(n<1 || n>9)
throw FatalException("Cluster::isReferenced() illegal reference");
if(references[n-1]>0)
return true;
return false;
}
// Initialise decryption using the specified object
CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hObject)
{
try
{
return SoftHSM::i()->C_DecryptInit(hSession, pMechanism, hObject);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Feed data to the running decryption operation in a session
CK_RV C_DecryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pDataLen)
{
try
{
return SoftHSM::i()->C_DecryptUpdate(hSession, pEncryptedData, ulEncryptedDataLen, pData, pDataLen);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Initialise digesting using the specified mechanism in the specified session
CK_RV C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism)
{
try
{
return SoftHSM::i()->C_DigestInit(hSession, pMechanism);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Update a running digest operation by digesting a secret key with the specified handle
CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject)
{
try
{
return SoftHSM::i()->C_DigestKey(hSession, hObject);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Finalise the digest operation in the specified session and return the digest
CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen)
{
try
{
return SoftHSM::i()->C_DigestFinal(hSession, pDigest, pulDigestLen);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Initialise a verification operation the allows recovery of the signed data from the signature
CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
{
try
{
return SoftHSM::i()->C_VerifyRecoverInit(hSession, pMechanism, hKey);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Initialise object search in the specified session using the specified attribute template as search parameters
CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
try
{
return SoftHSM::i()->C_FindObjectsInit(hSession, pTemplate, ulCount);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
void PlayerQuickItem::initMpv(PlayerComponent* player)
{
m_mpv = player->getMpvHandle();
m_mpvGL = (mpv_opengl_cb_context *)mpv_get_sub_api(m_mpv, MPV_SUB_API_OPENGL_CB);
if (!m_mpvGL)
throw FatalException(tr("OpenGL not enabled in libmpv."));
mpv_opengl_cb_set_update_callback(m_mpvGL, on_update, (void *)this);
connect(player, &PlayerComponent::windowVisible, this, &QQuickItem::setVisible);
window()->update();
}
SndThr::SndThr(EmulApp *parent)
: QThread(parent), pleaseStop(false), trigDone(false), sndDone(false), app(parent), sndShm(0)
{
RTOS::ShmStatus shmStatus;
// do sound shm stuff..
sndShm = reinterpret_cast<SndShm *>(RTOS::shmAttach(SND_SHM_NAME, SND_SHM_SIZE, &shmStatus, true));
if (!sndShm) {
throw FatalException(QString("Cannot create shm to ") + SND_SHM_NAME + " reason was: " + RTOS::statusString(shmStatus));
}
memset(sndShm, 0, SND_SHM_SIZE);
sndShm->fifo_in[0] = sndShm->fifo_out[0] = -1;
sndShm->magic = SND_SHM_MAGIC;
*const_cast<unsigned *>(&sndShm->num_cards) = 1;
unsigned minor;
if (RTOS::createFifo(minor, SND_FIFO_SZ) == RTOS::INVALID_FIFO)
throw FatalException(QString("Cannot create out fifo for SndShm"));
sndShm->fifo_out[0] = minor;
if (RTOS::createFifo(minor, SND_FIFO_SZ) == RTOS::INVALID_FIFO)
throw FatalException(QString("Cannot create in fifo for SndShm"));
sndShm->fifo_in[0] = minor;
Debug() << "Sound Shm FIFOs - In: " << sndShm->fifo_in[0] << " Out: " << sndShm->fifo_out[0];
}
// Change or set the value of the specified attributes on the specified object
CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
try
{
return SoftHSM::i()->C_SetAttributeValue(hSession, hObject, pTemplate, ulCount);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Update a running multi-part decryption and verification operation
CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart, CK_ULONG ulEncryptedPartLen, CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
{
try
{
return SoftHSM::i()->C_DecryptVerifyUpdate(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Perform a single part verification operation and recover the signed data
CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen)
{
try
{
return SoftHSM::i()->C_VerifyRecover(hSession, pSignature, ulSignatureLen, pData, pulDataLen);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Finish searching for objects
CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession)
{
try
{
return SoftHSM::i()->C_FindObjectsFinal(hSession);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Continue the search for objects in the specified session
CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phObject, CK_ULONG ulMaxObjectCount, CK_ULONG_PTR pulObjectCount)
{
try
{
return SoftHSM::i()->C_FindObjects(hSession, phObject, ulMaxObjectCount, pulObjectCount);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Update a running signing operation with additional data
CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen)
{
try
{
return SoftHSM::i()->C_SignUpdate(hSession, pPart, ulPartLen);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Generate a secret key using the specified mechanism
CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phKey)
{
try
{
return SoftHSM::i()->C_GenerateKey(hSession, pMechanism, pTemplate, ulCount, phKey);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
// Finalise a running signing operation and return the signature
CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
{
try
{
return SoftHSM::i()->C_SignFinal(hSession, pSignature, pulSignatureLen);
}
catch (...)
{
FatalException();
}
return CKR_FUNCTION_FAILED;
}
