bool PluginMethodListenOnFile::ExecuteListenOnFile(
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
std::string filename;
bool skip_to_end = false;
try {
if (argCount < 3 ||
!NPVARIANT_IS_STRING(args[0]) ||
!NPVARIANT_IS_BOOLEAN(args[1]) ||
!NPVARIANT_IS_OBJECT(args[2])) {
NPN_SetException(
object_,
"invalid or missing params passed to function - expecting 3 params: "
"filename, skipToEnd, callback(status, data)");
return false;
}
callback_ = NPVARIANT_TO_OBJECT(args[2]);
skip_to_end = NPVARIANT_TO_BOOLEAN(args[1]);
// add ref count to callback object so it won't delete
NPN_RetainObject(callback_);
filename.append(
NPVARIANT_TO_STRING(args[0]).UTF8Characters,
NPVARIANT_TO_STRING(args[0]).UTF8Length);
} catch(...) {
}
if (nullptr == thread_.get()) {
thread_.reset(new utils::Thread);
if (!thread_->Start()) {
NPN_SetException(
__super::object_,
"an unexpected error occurred - couldn't start file listening thread");
return false;
}
}
std::wstring wide_filename = utils::Encoders::utf8_decode(filename);
if (!file_stream_.Initialize(wide_filename.c_str(), this, skip_to_end)) {
NPN_SetException(
__super::object_,
"an unexpected error occurred - couldn't open the file for read access");
return false;
}
return thread_->PostTask(
std::bind(
&PluginMethodListenOnFile::StartListening,
this));
}
bool PluginMethodListenOnFile::ExecuteStopFileListen(
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
std::string id;
try {
if (argCount < 1 || !NPVARIANT_IS_STRING(args[0])) {
NPN_SetException(
object_,
"invalid or missing params passed to function - expecting 1 params: "
"id");
return false;
}
id.append(
NPVARIANT_TO_STRING(args[0]).UTF8Characters,
NPVARIANT_TO_STRING(args[0]).UTF8Length);
}
catch (...) {
}
TextFileThreadMap::iterator iter = threads_.find(id);
if (iter != threads_.end()) {
if (!iter->second.first->StopListening()) {
NPN_SetException(
__super::object_,
"an unexpected error occurred - couldn't stop existing listener");
return false;
}
if (!iter->second.second->Stop()) {
NPN_SetException(
__super::object_,
"an unexpected error occurred - couldn't stop existing listener thread");
return false;
}
delete iter->second.first;
delete iter->second.second;
threads_.erase(id);
if (nullptr != ids_to_callbacks_[id]) {
NPN_ReleaseObject(ids_to_callbacks_[id]);
ids_to_callbacks_[id] = nullptr;
ids_to_callbacks_.erase(id);
}
}
return true;
}
static bool NPClass_Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32 argCount, NPVariant *result)
{
NPClass_Prolog;
const QByteArray slotName = NPN_UTF8FromIdentifier(name);
int slotIndex = publicMethodIndex(npobj, slotName, static_cast<int>(argCount));
if (slotIndex == -1) {
NPN_SetException(npobj, QByteArray("No method '" + slotName + "' with " + QByteArray::number(argCount) + " parameters").constData());
return false;
}
const QMetaMethod slot = qobject->metaObject()->method(slotIndex);
QList<QByteArray> parameterTypes = slot.parameterTypes();
if (parameterTypes.count() != static_cast<int>(argCount)) {
NPN_SetException(npobj, QByteArray("Wrong parameter count for method " + slotName).constData());
return false;
}
QVariant returnVariant(QVariant::nameToType(slot.typeName()), (void*)0);
QVector<QVariant> variants(parameterTypes.count()); // keep data alive
QVector<const void*> metacallArgs(parameterTypes.count() + 1); // arguments for qt_metacall
metacallArgs[0] = returnVariant.data(); // args[0] == return value
for (int p = 0; p < parameterTypes.count(); ++p) {
QVariant::Type type = QVariant::nameToType(parameterTypes.at(p));
if (type == QVariant::Invalid && parameterTypes.at(p) != "QVariant") {
NPN_SetException(npobj, QString("Parameter %1 in method '%2' has invalid type")
.arg(p).arg(QString::fromUtf8(slotName)).toAscii().constData());
return false;
}
QVariant qvar = args[p];
if (type != QVariant::Invalid && !qvar.convert(type)) {
NPN_SetException(npobj, QString("Parameter %1 to method '%2' needs to be convertable to '%3'")
.arg(p).arg(QString::fromUtf8(slotName)).arg(QString::fromAscii(parameterTypes.at(p))).toAscii().constData());
return false;
}
variants[p] = qvar;
if (type == QVariant::Invalid)
metacallArgs[p + 1] = &variants.at(p);
else
metacallArgs[p + 1] = variants.at(p).constData(); // must not detach!
}
qobject->qt_metacall(QMetaObject::InvokeMetaMethod, slotIndex, const_cast<void**>(metacallArgs.data()));
if (returnVariant.isValid() && result)
*result = NPVariant::fromQVariant(This, returnVariant);
return true;
}
bool nsScriptableObjectOverwolfSample::Echo(
NPIdentifier name,
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
if (argCount < 2 ||
!NPVARIANT_IS_STRING(args[0]) ||
!NPVARIANT_IS_OBJECT(args[1])) {
NPN_SetException(this, "invalid params passed to function");
return true;
}
// add ref count to callback object so it won't delete
NPN_RetainObject(NPVARIANT_TO_OBJECT(args[1]));
// convert into std::string
std::string message;
message.append(
NPVARIANT_TO_STRING(args[0]).UTF8Characters,
NPVARIANT_TO_STRING(args[0]).UTF8Length);
// post to separate thread so that we are responsive
return thread_->PostTask(
std::bind(
&nsScriptableObjectOverwolfSample::EchoTask,
this,
message,
NPVARIANT_TO_OBJECT(args[1])));
}
void
StatementObject::GetTypeInfo(int dataType)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return;
}
NPError rc = Close();
if (rc != NPERR_NO_ERROR)
return;
SQLRETURN code = SQLGetTypeInfo(m_hstmt, dataType);
if (!SQL_SUCCEEDED(code) && code != SQL_NO_DATA) {
StoreError(SQL_HANDLE_STMT, m_hstmt);
return;
}
SQLSMALLINT cols;
if (SQL_SUCCEEDED(SQLNumResultCols(m_hstmt, &cols)))
m_columnCount = cols;
SQLLEN rcnt;
if (SQL_SUCCEEDED(SQLRowCount(m_hstmt, &rcnt)))
m_rowCount = rcnt;
}
bool nsScriptableObjectOverwolfSample::Add(
NPIdentifier name,
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
if (argCount < 3 ||
!NPVARIANT_IS_DOUBLE(args[0]) ||
!NPVARIANT_IS_DOUBLE(args[1]) ||
!NPVARIANT_IS_OBJECT(args[2])) {
NPN_SetException(this, "invalid params passed to function");
return true;
}
// add ref count to callback object so it won't delete
NPN_RetainObject(NPVARIANT_TO_OBJECT(args[2]));
// post to separate thread so that we are responsive
return thread_->PostTask(
std::bind(
&nsScriptableObjectOverwolfSample::AddTask,
this,
NPVARIANT_TO_DOUBLE(args[0]),
NPVARIANT_TO_DOUBLE(args[1]),
NPVARIANT_TO_OBJECT(args[2])));
}
NPError
StatementObject::MoreResults(bool *retval)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
SQLRETURN rc = SQLMoreResults(m_hstmt);
if (SQL_SUCCEEDED(rc)) {
SQLSMALLINT cols;
if (SQL_SUCCEEDED(SQLNumResultCols(m_hstmt, &cols)))
m_columnCount = cols;
if (m_columnCount > 0)
*retval = true;
else
*retval = false;
return NPERR_NO_ERROR;
} else if (rc == SQL_NO_DATA) {
*retval = false;
return NPERR_NO_ERROR;
} else {
StoreError(SQL_HANDLE_STMT, m_hstmt);
return NPERR_GENERIC_ERROR;
}
}
bool nsScriptableObjectRawInput::DeleteInstance(
NPIdentifier name,
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
if (argCount != 2 ||
!NPVARIANT_IS_DOUBLE(args[0]) ||
!NPVARIANT_IS_OBJECT(args[1])) {
NPN_SetException(this, "(DeleteInstance) invalid params passed to function");
return true;
}
int32_t id = (int32_t)(int)floor(NPVARIANT_TO_DOUBLE(args[0]) + 0.5); // all numbers come in as double in chrome...
bool foundAndDeleted = PluginMethodKeyCapture::DeleteInstance(id);
NPVariant out_args[2];
NPVariant ret_val;
BOOLEAN_TO_NPVARIANT(foundAndDeleted, out_args[0]);
INT32_TO_NPVARIANT(id, out_args[1]);
// fire callback
NPN_InvokeDefault(
__super::npp_,
NPVARIANT_TO_OBJECT(args[1]),
out_args,
2,
&ret_val);
NPN_ReleaseVariantValue(&ret_val);
return true;
}
static bool NPClass_Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32 argCount, NPVariant *result)
{
NPClass_Prolog;
int slotIndex = publicMethodIndex(npobj, name);
if (slotIndex == -1) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("No such method " + qname).constData());
return false;
}
const QMetaMethod slot = qobject->metaObject()->method(slotIndex);
QList<QByteArray> parameterTypes = slot.parameterTypes();
if (parameterTypes.count() != static_cast<int>(argCount)) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Wrong parameter count for method " + qname).constData());
return false;
}
QVariant returnVariant(QVariant::nameToType(slot.typeName()), (void *)0);
QVector<QVariant> variants(parameterTypes.count()); // keep data alive
QVector<const void *> metacallArgs(parameterTypes.count() + 1); // arguments for qt_metacall
metacallArgs[0] = returnVariant.data(); // args[0] == return value
for (int p = 0; p < parameterTypes.count(); ++p) {
QVariant::Type type = QVariant::nameToType(parameterTypes.at(p));
if (type == QVariant::Invalid) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Unsupported parameter in method " + qname).constData());
return false;
}
QVariant qvar = args[p];
if (!qvar.convert(type)) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Unsupported parameter value in method " + qname).constData());
return false;
}
variants[p] = qvar;
metacallArgs[p + 1] = variants.at(p).constData(); // must not detach!
}
qobject->qt_metacall(QMetaObject::InvokeMetaMethod, slotIndex, const_cast<void * *>(metacallArgs.data()));
if (returnVariant.isValid() && result)
*result = NPVariant::fromQVariant(This, returnVariant);
return true;
}
bool
xplayerNPObject::Throw (const char *aMessage)
{
NOTE (g_print ("xplayerNPObject::Throw [%p] : %s\n", (void*) this, aMessage));
NPN_SetException (this, aMessage);
return false;
}
bool nsScriptableObjectRawInput::Invoke(
NPIdentifier name,
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
#ifdef _DEBUG
NPUTF8* szName = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)szName);
#endif
// dispatch method to appropriate handler
MethodsMap::iterator iter = methods_.find(name);
if (iter == methods_.end()) {
GenericMethodsMap::iterator generic_iter = generic_methods_.find(name);
if (generic_iter == generic_methods_.end()) {
// should never reach here
NPN_SetException(this, "bad function called??");
return false;
}
return (this->*generic_iter->second)(name, args, argCount, result);
}
PluginMethod* plugin_method = iter->second->Clone(this, npp_, args, argCount, result);
if (nullptr == plugin_method) {
return false;
}
utils::Thread* thread = 0;
if (plugin_method->GetName().compare("RawInputMonitor") == 0) {
thread = thread_key.get();
if (thread->isQueueEmpty()) // this thread only has one task
return thread->PostTask(std::bind(&nsScriptableObjectRawInput::ExecuteMethod, this, plugin_method));
else
return true;
}
else
{
NPN_SetException(this, "could not find thread??");
return false;
}
}
void
StatementObject::GetForeignKeys(const NPVariant *arg0, const NPVariant *arg1,
const NPVariant *arg2, const NPVariant *arg3, const NPVariant *arg4,
const NPVariant *arg5)
{
NPString *pcat = NULL;
NPString *psch = NULL;
NPString *ptbl = NULL;
NPString *fcat = NULL;
NPString *fsch = NULL;
NPString *ftbl = NULL;
if (NPVARIANT_IS_STRING(*arg0))
pcat = (NPString*)&NPVARIANT_TO_STRING(*arg0);
if (NPVARIANT_IS_STRING(*arg1))
psch = (NPString*)&NPVARIANT_TO_STRING(*arg1);
if (NPVARIANT_IS_STRING(*arg2))
ptbl = (NPString*)&NPVARIANT_TO_STRING(*arg2);
if (NPVARIANT_IS_STRING(*arg3))
fcat = (NPString*)&NPVARIANT_TO_STRING(*arg3);
if (NPVARIANT_IS_STRING(*arg4))
fsch = (NPString*)&NPVARIANT_TO_STRING(*arg4);
if (NPVARIANT_IS_STRING(*arg5))
ftbl = (NPString*)&NPVARIANT_TO_STRING(*arg5);
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return;
}
NPError rc = Close();
if (rc != NPERR_NO_ERROR)
return;
SQLRETURN code = SQLForeignKeysW(m_hstmt,
(pcat?nsWString(pcat).Data():NULL), (pcat?SQL_NTS:0),
(psch?nsWString(psch).Data():NULL), (psch?SQL_NTS:0),
(ptbl?nsWString(ptbl).Data():NULL), (ptbl?SQL_NTS:0),
(fcat?nsWString(fcat).Data():NULL), (fcat?SQL_NTS:0),
(fsch?nsWString(fsch).Data():NULL), (fsch?SQL_NTS:0),
(ftbl?nsWString(ftbl).Data():NULL), (ftbl?SQL_NTS:0));
if (!SQL_SUCCEEDED(code) && code != SQL_NO_DATA) {
StoreError(SQL_HANDLE_STMT, m_hstmt);
return;
}
SQLSMALLINT cols;
if (SQL_SUCCEEDED(SQLNumResultCols(m_hstmt, &cols)))
m_columnCount = cols;
SQLLEN rcnt;
if (SQL_SUCCEEDED(SQLRowCount(m_hstmt, &rcnt)))
m_rowCount = rcnt;
}
static bool NPClass_GetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result)
{
NPClass_Prolog;
const QByteArray qname = NPN_UTF8FromIdentifier(name);
QVariant qvar = qobject->property(qname);
if (!qvar.isValid()) {
NPN_SetException(npobj, QByteArray("Failed to get value for property " + qname).constData());
return false;
}
*result = NPVariant::fromQVariant(This, qvar);
return true;
}
bool RuntimeNPObject::returnInvokeResult(RuntimeNPObject::InvokeResult result)
{
switch( result )
{
case INVOKERESULT_NO_ERROR:
return true;
case INVOKERESULT_GENERIC_ERROR:
break;
case INVOKERESULT_NO_SUCH_METHOD:
NPN_SetException(this, "No such method or arguments mismatch");
break;
case INVOKERESULT_INVALID_ARGS:
NPN_SetException(this, "Invalid arguments");
break;
case INVOKERESULT_INVALID_VALUE:
NPN_SetException(this, "Invalid value in assignment");
break;
case INVOKERESULT_OUT_OF_MEMORY:
NPN_SetException(this, "Out of memory");
break;
}
return false;
}
NPError
StatementObject::GetColumnName(int index, const char **retval)
{
NPError rc;
SQLWCHAR colName[512];
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
if (index < 0 || index >= m_columnCount) {
NPN_SetException(this, "Column index is out of range");
return NPERR_GENERIC_ERROR;
}
index++;
rc = CheckStmtRC(SQLDescribeColW (m_hstmt, index, colName,
sizeof(colName)/sizeof(wchar_t),
NULL, NULL, NULL, NULL, NULL));
if (rc == NPERR_NO_ERROR)
*retval = strdup_WtoU8((const wchar_t *)colName);
return rc;
}
NPError
StatementObject::IsColumnNullable(int index, bool *retval)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
if (index < 0 || index >= m_columnCount) {
NPN_SetException(this, "Column index is out of range");
return NPERR_GENERIC_ERROR;
}
index++;
SQLLEN v;
NPError rc = CheckStmtRC(SQLColAttributesW (m_hstmt, index,
SQL_COLUMN_NULLABLE, NULL, 0, NULL, &v));
if (rc != NPERR_NO_ERROR)
return rc;
*retval =(v != 0? true: false);
return rc;
}
bool JsAgent::onHandleReturn(const Variant& varRet) {
if(!varRet.isObject()) {
Debug::println("JsAgent::onHandleReturn> NPN_Invoke did not return an object");
return false;
}
NPObject* pReturn = varRet.asObject();
Variant varFlag;
if(!NPN_GetProperty(getNPP(), pReturn, methods.index0, varFlag.ptr())) {
Debug::println("JsAgent::onHandleReturn> ret[0] failed");
return false;
}
Variant varResult;
if(!NPN_GetProperty(getNPP(), pReturn, methods.index1, varResult.ptr())) {
Debug::println("JsAgent::onHandleReturn> ret[1] failed");
return false;
}
if(!varFlag.isBool()) {
Debug::println("JsAgent::onHandleReturn> flag was not bool");
return false;
}
ReturnMessage retMsg;
retMsg.isException = varFlag.asBool();
std::string strRet = varResult.toString(getNPP());
if(retMsg.isException) {
Debug::println("JsAgent::onHandleReturn> Exception: '%s'", strRet.c_str());
NPN_SetException(this, strRet.c_str());
}
else {
Debug::println("JsAgent::onHandleReturn> returned: %s", strRet.c_str());
}
if(!wrapLocalValue(varResult, retMsg.value)) {
Debug::println("JsAgent::onHandleReturn> wrapLocalValue() failed");
return false;
}
ArchiveWriter<Channel> ar(*m_channel);
if(!Message::send(retMsg, ar)) {
Debug::println("JsAgent::onHandleReturn> Message::send() failed");
return false;
}
return true;
}
void
StatementObject::GetProcedureColumns(const NPVariant *arg0, const NPVariant *arg1,
const NPVariant *arg2, const NPVariant *arg3)
{
NPString *cat = NULL;
NPString *sch = NULL;
NPString *prc = NULL;
NPString *col = NULL;
if (NPVARIANT_IS_STRING(*arg0))
cat = (NPString*)&NPVARIANT_TO_STRING(*arg0);
if (NPVARIANT_IS_STRING(*arg1))
sch = (NPString*)&NPVARIANT_TO_STRING(*arg1);
if (NPVARIANT_IS_STRING(*arg2))
prc = (NPString*)&NPVARIANT_TO_STRING(*arg2);
if (NPVARIANT_IS_STRING(*arg3))
col = (NPString*)&NPVARIANT_TO_STRING(*arg3);
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return;
}
NPError rc = Close();
if (rc != NPERR_NO_ERROR)
return;
SQLRETURN code = SQLProcedureColumnsW(m_hstmt,
(cat?nsWString(cat).Data():NULL), (cat?SQL_NTS:0),
(sch?nsWString(sch).Data():NULL), (sch?SQL_NTS:0),
(prc?nsWString(prc).Data():NULL), (prc?SQL_NTS:0),
(col?nsWString(col).Data():NULL), (col?SQL_NTS:0));
if (!SQL_SUCCEEDED(code) && code != SQL_NO_DATA) {
StoreError(SQL_HANDLE_STMT, m_hstmt);
return;
}
SQLSMALLINT cols;
if (SQL_SUCCEEDED(SQLNumResultCols(m_hstmt, &cols)))
m_columnCount = cols;
SQLLEN rcnt;
if (SQL_SUCCEEDED(SQLRowCount(m_hstmt, &rcnt)))
m_rowCount = rcnt;
}
bool nsScriptableObjectRawInput::GetProperty(
NPIdentifier name, NPVariant *result) {
PropertiesMap::iterator iter = properties_.find(name);
if (iter == properties_.end()) {
NPN_SetException(this, "unknown property!?");
return true;
}
char *resultString = (char*)NPN_MemAlloc(iter->second.size());
memcpy(
resultString,
iter->second.c_str(),
iter->second.size());
STRINGN_TO_NPVARIANT(resultString, iter->second.size(), *result);
return true;
}
bool nsScriptableObjectOverwolfSample::Invoke(
NPIdentifier name,
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
#ifdef _DEBUG
NPUTF8* szName = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)szName);
#endif
// dispatch method to appropriate handler
MethodsMap::iterator iter = methods_.find(name);
if (iter == methods_.end()) {
// should never reach here
NPN_SetException(this, "bad function called??");
return false;
}
return (this->*iter->second)(name, args, argCount, result);
}
void
StatementObject::StoreError(SWORD fHandleType, SQLHANDLE handle)
{
SQLWCHAR szErrState[SQL_SQLSTATE_SIZE+1]; // SQL Error State string
SQLINTEGER dwErrCode; // Native Error code
SQLWCHAR szErrText[SQL_MAX_MESSAGE_LENGTH+1];// SQL Error Text string
SWORD wErrMsgLen; // Error message length
SQLWCHAR szBuffer[1024]; //SQL_SQLSTATE_SIZE+SQL_MAX_MESSAGE_LENGTH+1];
szBuffer[0] = 0;
SQLRETURN nErrResult; // Return Code from SQLGetDiagRec
SWORD sMsgNum = 1; // no of records
m_errMessage[0] = 0;
m_errState[0] = 0;
m_errCode = 0;
nErrResult = SQLGetDiagRecW(fHandleType, handle, sMsgNum,
szErrState, &dwErrCode, szErrText,
SQL_MAX_MESSAGE_LENGTH-1, &wErrMsgLen);
if (nErrResult != SQL_NO_DATA)
{
if(nErrResult == SQL_ERROR || nErrResult == SQL_INVALID_HANDLE){
wcscpy(m_errMessage, L"\nError in executing SQLGetDiagRecW function");
} else {
#ifdef XP_WIN
_snwprintf((wchar_t *)m_errMessage, sizeof(m_errMessage)/sizeof(wchar_t), L"\nSQL Error State : %s\nNative Error Code: %lX\nODBC Error : %s",(LPWSTR) szErrState, dwErrCode, (LPWSTR)szErrText);
#else
swprintf((wchar_t *)m_errMessage, sizeof(m_errMessage)/sizeof(wchar_t), L"\nSQL Error State : %ls\nNative Error Code: %lX\nODBC Error : %ls",(LPWSTR) szErrState, dwErrCode, (LPWSTR)szErrText);
#endif
m_errCode = (dwErrCode?dwErrCode:1);
wcscpy(m_errState, szErrState);
}
NPN_SetException(this, "$DB$");
}
}
//===============================================
NPError
StatementObject::Fetch(bool *retval)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
SQLRETURN rc = SQLFetch(m_hstmt);
if (SQL_SUCCEEDED(rc)) {
*retval = true;
return NPERR_NO_ERROR;
} else if (rc == SQL_NO_DATA) {
*retval = false;
return NPERR_NO_ERROR;
} else {
StoreError(SQL_HANDLE_STMT, m_hstmt);
return NPERR_GENERIC_ERROR;
}
}
NPError
StatementObject::AddParam(const NPVariant *value)
{
nsODBCParam* pRec = NULL;
if (NPVARIANT_IS_VOID(*value) || NPVARIANT_IS_NULL(*value)) {
pRec = new nsODBCParam();
} else if (NPVARIANT_IS_BOOLEAN(*value)) {
pRec = new nsODBCParam(NPVARIANT_TO_BOOLEAN(*value));
} else if (NPVARIANT_IS_INT32(*value)) {
pRec = new nsODBCParam(NPVARIANT_TO_INT32(*value));
} else if (NPVARIANT_IS_DOUBLE(*value)) {
double data = NPVARIANT_TO_DOUBLE(*value);
double delta = ceil(data);
if (data-0.000000001 <delta && data+0.000000001 > delta)
pRec = new nsODBCParam((int)data);
else
pRec = new nsODBCParam(data);
//--pRec = new nsODBCParam(NPVARIANT_TO_DOUBLE(*value));
} else if (NPVARIANT_IS_STRING(*value)) {
pRec = new nsODBCParam((NPString*)&NPVARIANT_TO_STRING(*value));
} else {
NPN_SetException(this, "Unsupported parameter type");
return NPERR_GENERIC_ERROR;
}
if (pRec)
m_params.push_back(pRec);
return NPERR_NO_ERROR;
}
bool nsScriptableObjectRawInput::SetProperty(
NPIdentifier name, const NPVariant *value) {
NPN_SetException(this, "this property is read-only!");
return true;
}
NPError
StatementObject::GetColumnType(int index, int *retval)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
if (index < 0 || index >= m_columnCount) {
NPN_SetException(this, "Column index is out of range");
return NPERR_GENERIC_ERROR;
}
index++;
SQLLEN t;
NPError rc = CheckStmtRC(SQLColAttributesW (m_hstmt, index,
SQL_COLUMN_TYPE, NULL, 0, NULL, &t));
if (rc != NPERR_NO_ERROR)
return rc;
switch(t) {
case SQL_CHAR:
*retval = VALUE_TYPE_CHAR;
break;
case SQL_NUMERIC:
*retval = VALUE_TYPE_NUMERIC;
break;
case SQL_DECIMAL:
*retval = VALUE_TYPE_DECIMAL;
break;
case SQL_INTEGER:
*retval = VALUE_TYPE_INTEGER;
break;
case SQL_SMALLINT:
*retval = VALUE_TYPE_SMALLINT;
break;
case SQL_FLOAT:
*retval = VALUE_TYPE_FLOAT;
break;
case SQL_REAL:
*retval = VALUE_TYPE_REAL;
break;
case SQL_DOUBLE:
*retval = VALUE_TYPE_DOUBLE;
break;
case SQL_DATE:
case SQL_TYPE_DATE:
*retval = VALUE_TYPE_DATE;
break;
case SQL_TIME:
case SQL_TYPE_TIME:
*retval = VALUE_TYPE_TIME;
break;
case SQL_TIMESTAMP:
case SQL_TYPE_TIMESTAMP:
*retval = VALUE_TYPE_TIMESTAMP;
break;
case SQL_VARCHAR:
*retval = VALUE_TYPE_VARCHAR;
break;
case SQL_LONGVARCHAR:
*retval = VALUE_TYPE_LONGVARCHAR;
break;
case SQL_BINARY:
*retval = VALUE_TYPE_BINARY;
break;
case SQL_VARBINARY:
*retval = VALUE_TYPE_VARBINARY;
break;
case SQL_LONGVARBINARY:
*retval = VALUE_TYPE_LONGVARBINARY;
break;
case SQL_BIGINT:
*retval = VALUE_TYPE_BIGINT;
break;
case SQL_TINYINT:
*retval = VALUE_TYPE_TINYINT;
break;
case SQL_BIT:
*retval = VALUE_TYPE_BIT;
break;
case SQL_WCHAR:
*retval = VALUE_TYPE_WCHAR;
break;
case SQL_WVARCHAR:
*retval = VALUE_TYPE_WVARCHAR;
break;
case SQL_WLONGVARCHAR:
*retval = VALUE_TYPE_WLONGVARCHAR;
break;
case SQL_GUID:
*retval = VALUE_TYPE_GUID;
break;
default:
*retval = VALUE_TYPE_CHAR;
break;
}
return rc;
}
// listenOnFile(id, filename, skipToEnd, callback(status, data) )
bool PluginMethodListenOnFile::ExecuteListenOnFile(
const NPVariant *args,
uint32_t argCount,
NPVariant *result) {
std::string id;
std::string filename;
bool skip_to_end = false;
NPObject* callback = nullptr;
try {
if (argCount < 4 ||
!NPVARIANT_IS_STRING(args[0]) ||
!NPVARIANT_IS_STRING(args[1]) ||
!NPVARIANT_IS_BOOLEAN(args[2]) ||
!NPVARIANT_IS_OBJECT(args[3])) {
NPN_SetException(
object_,
"invalid or missing params passed to function - expecting 4 params: "
"id, filename, skipToEnd, callback(id, status, data)");
return false;
}
callback = NPVARIANT_TO_OBJECT(args[3]);
skip_to_end = NPVARIANT_TO_BOOLEAN(args[2]);
// add ref count to callback object so it won't delete
NPN_RetainObject(callback);
id.append(
NPVARIANT_TO_STRING(args[0]).UTF8Characters,
NPVARIANT_TO_STRING(args[0]).UTF8Length);
filename.append(
NPVARIANT_TO_STRING(args[1]).UTF8Characters,
NPVARIANT_TO_STRING(args[1]).UTF8Length);
} catch(...) {
}
TextFileThreadMap::iterator iter = threads_.find(id);
if (iter != threads_.end()) {
if (!iter->second.first->StopListening()) {
NPN_SetException(
__super::object_,
"an unexpected error occurred - couldn't stop existing listener");
return false;
}
if (!iter->second.second->Stop()) {
NPN_SetException(
__super::object_,
"an unexpected error occurred - couldn't stop existing listener thread");
return false;
}
}
std::wstring wide_filename = utils::Encoders::utf8_decode(filename);
threads_.insert(
std::pair<std::string, TextFileThread>(
id,
TextFileThread(new utils::TxtFileStream, new utils::Thread)));
if (!threads_[id].first->Initialize(
id.c_str(),
wide_filename.c_str(),
this,
skip_to_end)) {
NPN_SetException(
__super::object_,
"an unexpected error occurred - couldn't open the file for read access");
return false;
}
if (!threads_[id].second->Start()) {
NPN_SetException(
__super::object_,
"an unexpected error occurred - couldn't start file listening thread");
return false;
}
// set a callback
TextFileIdToCallbackMap::iterator iter_callback = ids_to_callbacks_.find(id);
if (iter_callback != ids_to_callbacks_.end()) {
if (nullptr != ids_to_callbacks_[id]) {
NPN_ReleaseObject(ids_to_callbacks_[id]);
}
}
ids_to_callbacks_[id] = callback;
char* id_to_pass = new char[id.size()+1];
strcpy(id_to_pass, id.c_str());
return threads_[id].second->PostTask(
std::bind(
&PluginMethodListenOnFile::StartListening,
this,
id_to_pass));
}
NPError
StatementObject::GetVariant(int index, NPVariant *value)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
if (index < 0 || index >= m_columnCount) {
NPN_SetException(this, "Column index is out of range");
return NPERR_GENERIC_ERROR;
}
SQLLEN cbInd;
int type;
NPError rc;
GetColumnType(index, &type);
index++;
NULL_TO_NPVARIANT(*value);
switch (type) {
case VALUE_TYPE_BIT:
{
bool v_bool;
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BIT, &v_bool, 0, &cbInd));
if (rc != NPERR_NO_ERROR)
return rc;
if (cbInd != SQL_NULL_DATA)
BOOLEAN_TO_NPVARIANT(v_bool, *value);
break;
}
case VALUE_TYPE_TINYINT:
case VALUE_TYPE_SMALLINT:
case VALUE_TYPE_BIGINT:
case VALUE_TYPE_INTEGER:
{
SQLINTEGER v_int32;
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_LONG, &v_int32, 0, &cbInd));
if (rc != NPERR_NO_ERROR)
return rc;
if (cbInd != SQL_NULL_DATA)
INT32_TO_NPVARIANT(v_int32, *value);
break;
}
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_REAL:
case VALUE_TYPE_DOUBLE:
{
double v_double;
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_DOUBLE, &v_double, 0, &cbInd));
if (rc != NPERR_NO_ERROR)
return rc;
if (cbInd != SQL_NULL_DATA)
DOUBLE_TO_NPVARIANT(v_double, *value);
break;
}
/**
case VALUE_TYPE_BINARY:
case VALUE_TYPE_VARBINARY:
case VALUE_TYPE_LONGVARBINARY:
{
const char hexString[] = "0123456789ABCDEF";
SQLLEN len;
SQLWCHAR buf[32];
unsigned char *pin;
char *pout;
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BINARY, buf, 0, &len));
if (rc != NPERR_NO_ERROR)
return rc;
if (len == SQL_NO_TOTAL)
{
const SQLLEN dwUnit = 8192;
unsigned char *pBuff;
unsigned char *pData = NULL;
SQLLEN dwAvialable;
SQLLEN bufSize = dwUnit;
char *data = NULL;
pData = (unsigned char *)NPN_MemAlloc(bufSize);
if (!pData) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
len = 0;
pBuff = pData;
while(1) {
SQLRETURN ret;
pBuff = pData + len;
ret = SQLGetData(m_hstmt, index, SQL_C_BINARY, pBuff, dwUnit, &dwAvialable);
if (ret == SQL_NO_DATA_FOUND)
break;
if ((rc = CheckStmtRC(ret)) != NPERR_NO_ERROR)
return rc;
if (dwAvialable < dwUnit) {
len += dwAvialable;
break;
}
len += dwUnit;
bufSize += dwUnit;
unsigned char* tmp = (unsigned char*)NPN_MemAlloc(bufSize);
if (!pBuff) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
memcpy(pBuff, pData, len);
NPN_MemFree(pData);
pData = pBuff;
pBuff = pData + len;
}
data = (char*)NPN_MemAlloc(len*2+1);
if (!data) {
NPN_MemFree(pData);
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
pout = data;
pin = pData;
while(len--) {
unsigned char binVal = *pin++;
*pout++ = hexString[(binVal >> 4) & 0xf];
*pout++ = hexString[binVal & 0xf];
}
*pout = 0;
NPN_MemFree(pData);
STRING_TO_NPVARIANT(data, *value);
}
else if (len != SQL_NULL_DATA)
{
unsigned char *pData;
SQLLEN bufSize = len + 1;
char *data = NULL;
pData = (unsigned char *)NPN_MemAlloc(bufSize);
if (!pData) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BINARY, pData, bufSize, &len));
if (rc != NPERR_NO_ERROR)
return rc;
data = (char*)NPN_MemAlloc(len*2+1);
if (!data) {
NPN_MemFree(pData);
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
pout = data;
pin = pData;
while(len--) {
unsigned char binVal = *pin++;
*pout++ = hexString[(binVal >> 4) & 0xf];
*pout++ = hexString[binVal & 0xf];
}
*pout = 0;
NPN_MemFree(pData);
STRING_TO_NPVARIANT(data, *value);
}
break;
}
**/
case VALUE_TYPE_BINARY:
case VALUE_TYPE_VARBINARY:
case VALUE_TYPE_LONGVARBINARY:
case VALUE_TYPE_GUID:
case VALUE_TYPE_CHAR:
case VALUE_TYPE_VARCHAR:
case VALUE_TYPE_LONGVARCHAR:
case VALUE_TYPE_WCHAR:
case VALUE_TYPE_WVARCHAR:
case VALUE_TYPE_WLONGVARCHAR:
case VALUE_TYPE_UNKNOWN:
case VALUE_TYPE_NUMERIC:
case VALUE_TYPE_DECIMAL:
case VALUE_TYPE_DATE:
case VALUE_TYPE_TIME:
case VALUE_TYPE_TIMESTAMP:
default:
{
SQLLEN len;
SQLLEN dtype;
SQLWCHAR buf[32];
rc = CheckStmtRC(SQLColAttributesW (m_hstmt, index, SQL_COLUMN_TYPE, NULL, 0, NULL, &dtype));
if (rc != NPERR_NO_ERROR)
return rc;
if (dtype == SQL_LONGVARBINARY || dtype == SQL_VARBINARY || dtype == SQL_BINARY ||
dtype == SQL_LONGVARCHAR || dtype == SQL_VARCHAR || dtype == SQL_CHAR ||
dtype == SQL_WLONGVARCHAR || dtype == SQL_WVARCHAR || dtype == SQL_WCHAR)
{
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, buf, 0, &len));
if (rc != NPERR_NO_ERROR)
return rc;
if (len == SQL_NO_TOTAL)
{
const SQLLEN dwUnit = 4096*sizeof(SQLWCHAR)+sizeof(SQLWCHAR);
unsigned char *pBuff = NULL;
unsigned char *pData = NULL;
SQLLEN dwAvialable;
SQLLEN bufSize = dwUnit;
char *data = NULL;
SQLRETURN ret;
pData = (unsigned char *)NPN_MemAlloc(bufSize);
if (!pData) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
len = 0;
while(1) {
pBuff = pData + len;
ret = SQLGetData(m_hstmt, index, SQL_C_WCHAR, pBuff, dwUnit, &dwAvialable);
if (ret == SQL_NO_DATA_FOUND)
break;
if ((rc = CheckStmtRC(ret)) != NPERR_NO_ERROR)
return rc;
if (dwAvialable < dwUnit) {
len += dwAvialable;
break;
}
len += dwUnit - sizeof(SQLWCHAR);
bufSize += dwUnit - sizeof(SQLWCHAR);
unsigned char* tmp = (unsigned char*)NPN_MemAlloc(bufSize);
if (!tmp) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
memcpy(tmp, pData, len);
NPN_MemFree(pData);
pData = tmp;
}
data = strdup_WtoU8((SQLWCHAR *)pData);
if (!data) {
NPN_MemFree(pData);
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
NPN_MemFree(pData);
STRING_TO_NPVARIANT(data, *value);
}
else if (len != SQL_NULL_DATA)
{
unsigned char *pData;
SQLLEN bufSize = len + sizeof(SQLWCHAR);
char *data = NULL;
pData = (unsigned char *)NPN_MemAlloc(bufSize);
if (!pData) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, pData, bufSize, &len));
if (rc != NPERR_NO_ERROR)
return rc;
data = strdup_WtoU8((SQLWCHAR *)pData);
if (!data) {
NPN_MemFree(pData);
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
NPN_MemFree(pData);
STRING_TO_NPVARIANT(data, *value);
}
} else {
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, buf, sizeof(buf), &len));
if (rc != NPERR_NO_ERROR)
return rc;
if (len != SQL_NULL_DATA) {
const char *data = strdup_WtoU8(buf);
if (!data) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
STRING_TO_NPVARIANT(data, *value);
}
}
break;
}
}
return NPERR_NO_ERROR;
}
NPError
StatementObject::Execute(NPString *query)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
NPError rc = Close();
if (rc != NPERR_NO_ERROR)
return rc;
/**********/
int i = 0;
VecODBCParams::iterator p;
if (!m_params.empty()) {
for(p = m_params.begin(); p < m_params.end(); p++) {
nsODBCParam *val = *p;
if (val == NULL) {
return NPERR_GENERIC_ERROR;
}
i++;
switch(val->mType) {
case nsODBCParam::VTYPE_BOOL :
{
val->mInd = 0;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_BIT, SQL_BIT, sizeof(bool), 0, &(val->mVal.mBoolValue),
0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
case nsODBCParam::VTYPE_INT32 :
{
val->mInd = 0;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, sizeof(int), 0, &(val->mVal.mInt32Value),
0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
case nsODBCParam::VTYPE_DOUBLE :
{
val->mInd = 0;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_DOUBLE, SQL_DOUBLE, sizeof(double), 0, &(val->mVal.mDoubleValue),
0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
case nsODBCParam::VTYPE_STRING :
{
nsWString *v_str = val->mVal.mStringValue;
val->mInd = SQL_NTS;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_WCHAR, (val->mIsLong?SQL_WLONGVARCHAR:SQL_WVARCHAR),
v_str->Length(), 0, v_str->Data(), 0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
#if 0
case nsIDataType::VTYPE_ARRAY :
{
nsBinary *v_bin = val->mVal.mBinValue;
val->mInd = v_bin->Length();
rv = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_BINARY, (val->mIsLong?SQL_LONGVARBINARY:SQL_VARBINARY),
v_bin->Length(), 0, v_bin->Data(), 0, (SQLINTEGER *)&(val->mInd)));
if (rv != NS_OK)
return rv;
break;
}
#endif
default:
{
val->mInd = SQL_NULL_DATA;
rc = CheckStmtRC(SQLBindParameter(m_hstmt, i, SQL_PARAM_INPUT,
SQL_C_CHAR, SQL_VARCHAR, 0, 0, NULL, 0, (SQLLEN *)&(val->mInd)));
if (rc != NPERR_NO_ERROR)
return rc;
break;
}
}
}
}
/**********/
SQLRETURN code = SQLExecDirectW (m_hstmt, nsWString(query).Data(), SQL_NTS);
if (!SQL_SUCCEEDED(code) && code != SQL_NO_DATA) {
StoreError(SQL_HANDLE_STMT, m_hstmt);
ClearParams();
return NPERR_GENERIC_ERROR;
}
SQLFreeStmt (m_hstmt, SQL_RESET_PARAMS);
ClearParams();
SQLSMALLINT cols;
if (SQL_SUCCEEDED(SQLNumResultCols(m_hstmt, &cols)))
m_columnCount = cols;
SQLLEN rcnt;
if (SQL_SUCCEEDED(SQLRowCount(m_hstmt, &rcnt)))
m_rowCount = rcnt;
return NPERR_NO_ERROR;
}
bool
StatementObject::Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
//sprintf(tmp, "stmt Invoke [%s]\n", NPN_UTF8FromIdentifier(name)); log(tmp);
NPError rc;
VOID_TO_NPVARIANT(*result);
int index = 0;
if (name == mc_Init_id) {
if (argCount < 2) {
NPN_SetException(this, "Too few parameters count");
return true;
}
#if 0
if (!(NPVARIANT_IS_INT32(args[0]) && NPVARIANT_IS_OBJECT(args[1]))) {
NPN_SetException(this, "Wrong argument type");
return true;
}
SQLHANDLE hdbc = (SQLHANDLE)(long)NPVARIANT_TO_INT32(args[0]);
#else
if (!(NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_OBJECT(args[1]))) {
NPN_SetException(this, "Wrong argument type");
return true;
}
SQLHANDLE hdbc = (SQLHANDLE)NPVARIANT_TO_OBJECT(args[0]);
#endif
Init(hdbc, NPVARIANT_TO_OBJECT(args[1]));
return true;
} else if (name == mc_AddParameter_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
AddParam(args);
return true;
} else if (name == mc_Execute_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!NPVARIANT_IS_STRING(args[0])) {
NPN_SetException(this, "Wrong argument type");
return true;
}
Execute((NPString*)&NPVARIANT_TO_STRING(args[0]));
return true;
} else if (name == mc_Close_id) {
Close();
return true;
} else if (name == mc_Fetch_id) {
bool ret;
rc = Fetch(&ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_MoreResults_id) {
bool ret;
rc = MoreResults(&ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetColumnName_id) {
const char *ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = GetColumnName(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
STRING_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetVariant_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
GetVariant(index, result);
return true;
} else if (name == mc_GetColumnType_id) {
int ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = GetColumnType(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
INT32_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_IsColumnNullable_id) {
bool ret;
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
rc = IsColumnNullable(index, &ret);
if (rc != NPERR_NO_ERROR)
return true;
BOOLEAN_TO_NPVARIANT(ret, *result);
return true;
} else if (name == mc_GetTables_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetTables(&args[0], &args[1], &args[2], &args[3]);
return true;
} else if (name == mc_GetColumns_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetColumns(&args[0], &args[1], &args[2], &args[3]);
return true;
} else if (name == mc_GetTypeInfo_id) {
if (argCount < 1) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (NPVARIANT_IS_INT32(args[0]))
index = NPVARIANT_TO_INT32(args[0]);
else if (NPVARIANT_IS_DOUBLE(args[0]))
index = (int)NPVARIANT_TO_DOUBLE(args[0]);
else {
NPN_SetException(this, "Wrong argument type");
return true;
}
GetTypeInfo(index);
return true;
} else if (name == mc_GetPrimaryKeys_id) {
if (argCount < 3) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
GetPrimaryKeys(&args[0], &args[1], &args[2]);
return true;
} else if (name == mc_GetForeignKeys_id) {
if (argCount < 6) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[4]) || NPVARIANT_IS_STRING(args[4]))) {
NPN_SetException(this, "Wrong 5 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[5]) || NPVARIANT_IS_STRING(args[5]))) {
NPN_SetException(this, "Wrong 6 argument type");
return true;
}
GetForeignKeys(&args[0], &args[1], &args[2], &args[3], &args[4], &args[5]);
return true;
} else if (name == mc_GetProcedures_id) {
if (argCount < 3) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
GetProcedures(&args[0], &args[1], &args[2]);
return true;
} else if (name == mc_GetProcedureColumns_id) {
if (argCount < 4) {
NPN_SetException(this, "Too few parameters count");
return true;
}
if (!(NPVARIANT_IS_NULL(args[0]) || NPVARIANT_IS_STRING(args[0]))) {
NPN_SetException(this, "Wrong 1 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[1]) || NPVARIANT_IS_STRING(args[1]))) {
NPN_SetException(this, "Wrong 2 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[2]) || NPVARIANT_IS_STRING(args[2]))) {
NPN_SetException(this, "Wrong 3 argument type");
return true;
}
if (!(NPVARIANT_IS_NULL(args[3]) || NPVARIANT_IS_STRING(args[3]))) {
NPN_SetException(this, "Wrong 4 argument type");
return true;
}
GetProcedureColumns(&args[0], &args[1], &args[2], &args[3]);
return true;
}
return false;
}
int QtSignalForwarder::qt_metacall(QMetaObject::Call call, int index, void **args)
{
// no support for QObject method/properties etc!
if (!This || !This->npp || call != QMetaObject::InvokeMetaMethod
|| !This->qt.object)
return index;
switch (index) {
case -1:
{
QString msg = *(QString*)args[1];
NPN_Status(This->npp, msg.toLocal8Bit().constData());
}
break;
default:
{
QObject *qobject = This->qt.object;
if (!domNode)
NPN_GetValue(This->npp, NPNVPluginElementNPObject, &domNode);
if (!domNode)
break;
const QMetaObject *metaObject = qobject->metaObject();
if (index < metaOffset(metaObject, MetaMethod))
break;
const QMetaMethod method = metaObject->method(index);
Q_ASSERT(method.methodType() == QMetaMethod::Signal);
QByteArray signalSignature = method.signature();
QByteArray scriptFunction = signalSignature.left(signalSignature.indexOf('('));
NPIdentifier id = NPN_GetStringIdentifier(scriptFunction.constData());
if (NPN_HasMethod(This->npp, domNode, id)) {
QList<QByteArray> parameterTypes = method.parameterTypes();
QVector<NPVariant> parameters;
NPVariant result;
bool error = false;
for (int p = 0; p < parameterTypes.count(); ++p) {
QVariant::Type type = QVariant::nameToType(parameterTypes.at(p));
if (type == QVariant::Invalid) {
NPN_SetException(domNode, QByteArray("Unsupported parameter type in ") + scriptFunction);
error = true;
break;
}
QVariant qvar(type, args[p + 1]);
NPVariant npvar = NPVariant::fromQVariant(This, qvar);
if (npvar.type == NPVariant::Null || npvar.type == NPVariant::Void) {
NPN_SetException(domNode, QByteArray("Unsupported parameter value in ") + scriptFunction);
error =true;
break;
}
parameters += npvar;
}
if (error)
break;
NPError nperror = NPN_Invoke(This->npp, domNode, id, parameters.constData(), parameters.count(), &result);
if (nperror != NPERR_NO_ERROR && false) { // disabled, as NPN_Invoke seems to always return GENERICERROR
NPN_SetException(domNode, QByteArray("Error invoking event handler ") + scriptFunction);
}
// ### TODO: update return value (args[0]) (out-parameters not supported anyway)
NPN_ReleaseVariantValue(&result);
}
}
break;
}
return index;
}
