void convertToVariant(NPP npp, const Any& any, NPVariant* variant, bool result) { switch (any.getType()) { case Any::Empty: NULL_TO_NPVARIANT(*variant); break; case Any::Bool: BOOLEAN_TO_NPVARIANT(any.toBoolean(), *variant); break; case Any::Int32: case Any::Uint32: INT32_TO_NPVARIANT(static_cast<int32_t>(any), *variant); break; case Any::Int64: case Any::Uint64: case Any::Float32: case Any::Float64: DOUBLE_TO_NPVARIANT(static_cast<double>(any), *variant); break; case Any::Dynamic: if (any.isString()) { std::string value = any.toString(); if (value.length() == 0) { STRINGN_TO_NPVARIANT(0, 0, *variant); } else if (!result) { STRINGN_TO_NPVARIANT(value.c_str(), static_cast<uint32_t>(value.length()), *variant); } else { void* buffer = NPN_MemAlloc(value.length()); if (!buffer) { STRINGN_TO_NPVARIANT(0, 0, *variant); } else { memmove(buffer, value.c_str(), value.length()); STRINGN_TO_NPVARIANT(static_cast<NPUTF8*>(buffer), static_cast<uint32_t>(value.length()), *variant); } } } else { assert(any.isObject()); convertToVariant(npp, any.toObject(), variant, result); } break; default: VOID_TO_NPVARIANT(*variant); break; } }
//virtual void PluginMethodListenOnFile::OnError( const char* id, const char* message, unsigned int len) { TextFileIdToCallbackMap::iterator iter = ids_to_callbacks_.find(id); if ((iter == ids_to_callbacks_.end()) || (nullptr == iter->second)) { OutputDebugStringA("SimpleIOPlugin OnNewLine - missing callback error!"); return; } static bool write_to_trace = utils::ShouldWriteToTrace(); if (write_to_trace) { std::string str = "SimpleIOPlugin OnError - ["; str += id; str += "] "; str += message; OutputDebugStringA(str.c_str()); } NPVariant args[3]; NPVariant ret_val; STRINGN_TO_NPVARIANT( id, strlen(id), args[0]); BOOLEAN_TO_NPVARIANT( false, args[1]); STRINGN_TO_NPVARIANT( message, len, args[2]); // fire callback NPN_InvokeDefault( npp_, iter->second, args, 3, &ret_val); NPN_ReleaseVariantValue(&ret_val); }
void handleCallback(PluginObject* object, const char *url, NPReason reason, void *notifyData) { //assert(object); NPVariant args[2]; NPObject *windowScriptObject; browser->getvalue(object->npp, NPNVWindowNPObject, &windowScriptObject); NPIdentifier callbackIdentifier = notifyData; INT32_TO_NPVARIANT(reason, args[0]); char *strHdr = NULL; if (object->firstUrl && object->firstHeaders && object->lastUrl && object->lastHeaders) { // Format expected by JavaScript validator: four fields separated by \n\n: // First URL; first header block; last URL; last header block. // Note that header blocks already end with \n due to how NPStream::headers works. int len = strlen(object->firstUrl) + 2 + strlen(object->firstHeaders) + 1 + strlen(object->lastUrl) + 2 + strlen(object->lastHeaders) + 1; strHdr = (char*)malloc(len + 1); snprintf(strHdr, len + 1, "%s\n\n%s\n%s\n\n%s\n", object->firstUrl, object->firstHeaders, object->lastUrl, object->lastHeaders); STRINGN_TO_NPVARIANT(strHdr, len, args[1]); } else NULL_TO_NPVARIANT(args[1]); NPVariant browserResult; browser->invoke(object->npp, windowScriptObject, callbackIdentifier, args, 2, &browserResult); browser->releasevariantvalue(&browserResult); free(strHdr); }
// this is not called on the main thread - so we need to // use NPN_PluginThreadAsyncCall void nsScriptableObjectOverwolfSample::EchoTask( const std::string& message, NPObject* callback) { if (shutting_down_) { return; } NPVariant arg; NPVariant ret_val; STRINGN_TO_NPVARIANT( message.c_str(), message.size(), arg); // fire callback NPN_InvokeDefault( __super::npp_, callback, &arg, 1, &ret_val); NPN_ReleaseVariantValue(&ret_val); }
void convertV8ObjectToNPVariant(v8::Local<v8::Value> object, NPObject* owner, NPVariant* result) { VOID_TO_NPVARIANT(*result); // It is really the caller's responsibility to deal with the empty handle case because there could be different actions to // take in different contexts. ASSERT(!object.IsEmpty()); if (object.IsEmpty()) return; if (object->IsNumber()) DOUBLE_TO_NPVARIANT(object->NumberValue(), *result); else if (object->IsBoolean()) BOOLEAN_TO_NPVARIANT(object->BooleanValue(), *result); else if (object->IsNull()) NULL_TO_NPVARIANT(*result); else if (object->IsUndefined()) VOID_TO_NPVARIANT(*result); else if (object->IsString()) { v8::Handle<v8::String> str = object->ToString(); int length = str->Utf8Length() + 1; char* utf8Chars = reinterpret_cast<char*>(malloc(length)); str->WriteUtf8(utf8Chars, length, 0, v8::String::HINT_MANY_WRITES_EXPECTED); STRINGN_TO_NPVARIANT(utf8Chars, length-1, *result); } else if (object->IsObject()) { DOMWindow* window = V8Proxy::retrieveWindow(V8Proxy::currentContext()); NPObject* npobject = npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(object), window); if (npobject) _NPN_RegisterObject(npobject, owner); OBJECT_TO_NPVARIANT(npobject, *result); } }
void convertV8ObjectToNPVariant(v8::Local<v8::Value> object, NPObject* owner, NPVariant* result) { VOID_TO_NPVARIANT(*result); // It is really the caller's responsibility to deal with the empty handle case because there could be different actions to // take in different contexts. ASSERT(!object.IsEmpty()); if (object.IsEmpty()) return; if (object->IsInt32()) INT32_TO_NPVARIANT(object->NumberValue(), *result); else if (object->IsNumber()) DOUBLE_TO_NPVARIANT(object->NumberValue(), *result); else if (object->IsBoolean()) BOOLEAN_TO_NPVARIANT(object->BooleanValue(), *result); else if (object->IsNull()) NULL_TO_NPVARIANT(*result); else if (object->IsUndefined()) VOID_TO_NPVARIANT(*result); else if (object->IsString()) { v8::String::Utf8Value utf8(object); char* utf8_chars = strdup(*utf8); STRINGN_TO_NPVARIANT(utf8_chars, utf8.length(), *result); } else if (object->IsObject()) { WebCore::DOMWindow* window = WebCore::V8Proxy::retrieveWindow(WebCore::V8Proxy::currentContext()); NPObject* npobject = npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(object), window); if (npobject) _NPN_RegisterObject(npobject, owner); OBJECT_TO_NPVARIANT(npobject, *result); } }
bool xplayerNPObject::StringVariant (NPVariant* _result, const char* value, int32_t len) { if (!value) { NULL_TO_NPVARIANT (*_result); } else { char *dup; if (len < 0) { len = strlen (value); dup = (char*) NPN_MemDup (value, len + 1); } else { dup = (char*) NPN_MemDup (value, len); } if (dup) { STRINGN_TO_NPVARIANT (dup, len, *_result); } else { NULL_TO_NPVARIANT (*_result); } } return true; }
void cloud_spy_init_npvariant_with_string (NPVariant * var, const gchar * str) { gsize len = strlen (str); NPUTF8 * str_copy = static_cast<NPUTF8 *> (cloud_spy_nsfuncs->memalloc (len)); memcpy (str_copy, str, len); STRINGN_TO_NPVARIANT (str_copy, len, *var); }
void GnashPluginScriptObject::AddProperty(const std::string &name, const std::string &val) { NPIdentifier id = NPN_GetStringIdentifier(name.c_str()); NPVariant strvar; STRINGN_TO_NPVARIANT(val.c_str(), static_cast<int>(val.size()), strvar); SetProperty(id, strvar); }
bool NP_GetProperty(NPObject *npobj, NPIdentifier propName, NPVariant *result){ char * name = npnfuncs->utf8fromidentifier(propName); if(strcmp(name, PROP_OS) == 0){ size_t l = strlen(OSNAME); char * s = (char *)npnfuncs->memalloc(l + 1); memcpy(s, OSNAME, l); s[l] = '\0'; STRINGN_TO_NPVARIANT(s, l, *result); return true; #ifdef XP_WIN }else if(strcmp(name, PROP_WHERE) == 0){ char * buf = (char *)npnfuncs->memalloc(MAX_PATH); GetSystemDirectory(buf, MAX_PATH + 1); STRINGN_TO_NPVARIANT(buf, strlen(buf) , *result); return true; #endif } return false; }
bool SetReturnValue(const char *value, const size_t len, NPVariant &result) { const size_t dstLen = len + 1; char *resultString = (char *)browserFuncs->memalloc(dstLen); if (!resultString) { return false; } memcpy(resultString, value, len); resultString[dstLen - 1] = 0; STRINGN_TO_NPVARIANT(resultString, len, result); return true; }
bool convert_mrb_to_js_string(mrb_state *mrb, mrb_value value, NPP npp, NPVariant *result) { NPUTF8 *ptr = (NPUTF8 *)NPN_MemAlloc(RSTRING_LEN(value)); if (!ptr){ return false; } std::copy(RSTRING_PTR(value), RSTRING_END(value), ptr); STRINGN_TO_NPVARIANT(ptr, RSTRING_LEN(value), *result); return true; }
void convertToVariant(NPP npp, const std::string& value, NPVariant* variant, bool result) { if (value.length() == 0) { STRINGN_TO_NPVARIANT(0, 0, *variant); return; } if (!result) { STRINGN_TO_NPVARIANT(value.c_str(), static_cast<uint32_t>(value.length()), *variant); return; } void* buffer = NPN_MemAlloc(value.length()); if (!buffer) { STRINGN_TO_NPVARIANT(0, 0, *variant); return; } memmove(buffer, value.c_str(), value.length()); STRINGN_TO_NPVARIANT(static_cast<NPUTF8*>(buffer), static_cast<uint32_t>(value.length()), *variant); }
NPVariant NPRemoteObjectMap::npVariantDataToNPVariant(const NPVariantData& npVariantData, Plugin* plugin) { NPVariant npVariant; switch (npVariantData.type()) { case NPVariantData::Void: VOID_TO_NPVARIANT(npVariant); break; case NPVariantData::Null: NULL_TO_NPVARIANT(npVariant); break; case NPVariantData::Bool: BOOLEAN_TO_NPVARIANT(npVariantData.boolValue(), npVariant); break; case NPVariantData::Int32: INT32_TO_NPVARIANT(npVariantData.int32Value(), npVariant); break; case NPVariantData::Double: DOUBLE_TO_NPVARIANT(npVariantData.doubleValue(), npVariant); break; case NPVariantData::String: { NPString npString = createNPString(npVariantData.stringValue()); STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, npVariant); break; } case NPVariantData::LocalNPObjectID: { uint64_t npObjectID = npVariantData.localNPObjectIDValue(); ASSERT(npObjectID); NPObjectMessageReceiver* npObjectMessageReceiver = m_registeredNPObjects.get(npObjectID); if (!npObjectMessageReceiver) { ASSERT_NOT_REACHED(); VOID_TO_NPVARIANT(npVariant); break; } NPObject* npObject = npObjectMessageReceiver->npObject(); ASSERT(npObject); retainNPObject(npObject); OBJECT_TO_NPVARIANT(npObject, npVariant); break; } case NPVariantData::RemoteNPObjectID: { NPObject* npObjectProxy = createNPObjectProxy(npVariantData.remoteNPObjectIDValue(), plugin); OBJECT_TO_NPVARIANT(npObjectProxy, npVariant); break; } } return npVariant; }
static bool InvokeHW(NPObject *obj, const NPVariant *args, uint32_t argCount, NPVariant *result) { printf("*** InvokeHW\n"); if (result) { const char *msg = "hello, world."; const int msglength = strlen(msg) + 1; /* Note: msgcopy will be freed downstream by NPAPI, so */ /* it needs to be allocated here with NPN_MemAlloc. */ char *msgcopy = (char *)NPN_MemAlloc(msglength); strncpy(msgcopy, msg, msglength); STRINGN_TO_NPVARIANT(msgcopy, msglength - 1, *result); } return true; }
bool ObjectManager::GetProperty(NPObject *npObj, NPIdentifier name, NPVariant *value) { if (name == NPNFuncs.getstringidentifier("internalId")) { int len = strlen(MANAGER_OBJECT_ID); char *stra = (char*)NPNFuncs.memalloc(len + 1); strcpy(stra, MANAGER_OBJECT_ID); STRINGN_TO_NPVARIANT(stra, len, *value); return true; } if (name == NPNFuncs.getstringidentifier("isValid")) { BOOLEAN_TO_NPVARIANT(TRUE, *value); return true; } return false; }
// Provide the appropriate value to JS. bool BaseGetProperty(NPObject *obj, NPIdentifier name, NPVariant *result) { if (IS_IDENTIFIER("penAPI")) { // The main part of the API is defined in the PenAPIObject. // Retain and return this object. NPObject *penObj = g_api.penAPI; g_netscapeFuncs->retainobject(penObj); OBJECT_TO_NPVARIANT(penObj, *result); return true; } if (IS_IDENTIFIER("version")) { // Return the PLUGIN_VERSION. STRINGN_TO_NPVARIANT(strdup(PLUGIN_VERSION), sizeof(PLUGIN_VERSION), *result); return true; } return false; }
RuntimeNPObject::InvokeResult RuntimeNPObject::invokeResultString(const char *psz, NPVariant &result) { if( !psz ) NULL_TO_NPVARIANT(result); else { size_t len = strlen(psz); NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len); if( !retval ) return INVOKERESULT_OUT_OF_MEMORY; else { memcpy(retval, psz, len); STRINGN_TO_NPVARIANT(retval, len, result); } } return INVOKERESULT_NO_ERROR; }
static gboolean jsonify_variant (GVariant *variant, NPVariant *result) { gboolean ret; GVariant *real_value; JsonNode *root; JsonGenerator *generator; gsize json_length; gchar *json; gchar *buffer; ret = TRUE; /* DBus methods can return multiple values, * but we're only interested in the first. */ g_variant_get (variant, "(@*)", &real_value); root = json_gvariant_serialize (real_value); generator = json_generator_new (); json_generator_set_root (generator, root); json = json_generator_to_data (generator, &json_length); buffer = funcs.memalloc (json_length + 1); if (!buffer) { ret = FALSE; goto out; } strcpy (buffer, json); STRINGN_TO_NPVARIANT (buffer, json_length, *result); out: g_variant_unref (variant); g_variant_unref (real_value); json_node_free (root); g_free (json); return ret; }
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; }
void ConvertV8ObjectToNPVariant(v8::Local<v8::Value> object, NPObject *owner, NPVariant* result) { VOID_TO_NPVARIANT(*result); // It is really the caller's responsibility to deal with the empty handle // case because there could be different actions to take in different // contexts. ASSERT(!object.IsEmpty()); if (object.IsEmpty()) return; if (object->IsNumber()) { DOUBLE_TO_NPVARIANT(object->NumberValue(), *result); } else if (object->IsBoolean()) { BOOLEAN_TO_NPVARIANT(object->BooleanValue(), *result); } else if (object->IsNull()) { NULL_TO_NPVARIANT(*result); } else if (object->IsUndefined()) { VOID_TO_NPVARIANT(*result); } else if (object->IsString()) { v8::Handle<v8::String> str = object->ToString(); uint16_t *buf = new uint16_t[str->Length()+1]; str->Write(buf); std::string utf8 = WideToUTF8(reinterpret_cast<wchar_t*>(buf)); char* utf8_chars = strdup(utf8.c_str()); STRINGN_TO_NPVARIANT(utf8_chars, utf8.length(), *result); delete[] buf; } else if (object->IsObject()) { WebCore::DOMWindow* window = WebCore::V8Proxy::retrieveWindow(); NPObject* npobject = NPN_CreateScriptObject( 0, v8::Handle<v8::Object>::Cast(object), window); if (npobject) { _NPN_RegisterObject(npobject, owner); } OBJECT_TO_NPVARIANT(npobject, *result); } }
static gboolean plugin_get_shell_version (PluginObject *obj, NPVariant *result) { GVariant *res; const gchar *version; gsize length; gchar *buffer; gboolean ret; ret = TRUE; res = g_dbus_proxy_get_cached_property (obj->proxy, "ShellVersion"); if (res == NULL) { g_warning ("Failed to grab shell version."); version = "-1"; } else { g_variant_get (res, "&s", &version); } length = strlen (version); buffer = funcs.memalloc (length + 1); if (!buffer) { ret = FALSE; goto out; } strcpy (buffer, version); STRINGN_TO_NPVARIANT (buffer, length, *result); out: if (res) g_variant_unref (res); return ret; }
void NPRuntimeObjectMap::convertJSValueToNPVariant(ExecState* exec, JSValue value, NPVariant& variant) { JSLockHolder lock(exec); VOID_TO_NPVARIANT(variant); if (value.isNull()) { NULL_TO_NPVARIANT(variant); return; } if (value.isUndefined()) { VOID_TO_NPVARIANT(variant); return; } if (value.isBoolean()) { BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), variant); return; } if (value.isNumber()) { DOUBLE_TO_NPVARIANT(value.toNumber(exec), variant); return; } if (value.isString()) { NPString npString = createNPString(value.toString(exec)->value(exec).utf8()); STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, variant); return; } if (value.isObject()) { NPObject* npObject = getOrCreateNPObject(exec->vm(), asObject(value)); OBJECT_TO_NPVARIANT(npObject, variant); return; } ASSERT_NOT_REACHED(); }
// GetVariable sends a message to the player that looks like this: // "Command Name\n", ie... "GetVariable var1\n". Then it waits // for the response with the type and value. GnashNPVariant GnashPluginScriptObject::GetVariable(const std::string &name) { std::vector<std::string> iargs; std::string str = plugin::ExternalInterface::makeString(name); iargs.push_back(str); str = plugin::ExternalInterface::makeInvoke("GetVariable", iargs); log_debug("Trying to get a value for %s.", name); size_t ret = writePlayer(str); if (ret != str.size()) { // If all the browser wants is the version, we don't need to // ask the standalone player for this value. YouTube at // least depends on this for some pages which want this to // be greater than 8.0.0. This appears to potentially be // Google's way of trying to revent downloaders, as this requires // plugin support. NPVariant value; if (name == "$version") { STRINGN_TO_NPVARIANT("LNX 10,0,r999", 13, value); } else { log_error("Couldn't send GetVariable request, network problems."); NULL_TO_NPVARIANT(value); } return value; } // Have the read function allocate the memory std::string data = readPlayer(); if (data.empty()) { return GnashNPVariant(); } GnashNPVariant parsed = plugin::ExternalInterface::parseXML(this, data); printNPVariant(&parsed.get()); return parsed; }
void getResultAsVariant(NPVariant *result) { NPUTF8 *res = (NPUTF8 *)malloc(strlen(gBuff)+1); memcpy(res, gBuff, strlen(gBuff)+1); // Get rid of leading white spaces while(isspace(res[0])) { if(strlen(res) > 1) { memmove(res,res+1,strlen(res)-1); } else { res[0] = '\0'; break; } } // Get rid of trailing white spaces while(strlen(res) > 0 && isspace(res[strlen(res)-1])) { res[strlen(res)-1] = '\0'; } if(strlen(res) > 0) { // Try to convert to integer char *endPtr; int32_t intResult = strtol(res, &endPtr, 10); if(res != NULL && *endPtr == '\0') { INT32_TO_NPVARIANT(intResult, *result); return; } // Try to convert to double double doubleResult = strtod(res, &endPtr); if(res != NULL && *endPtr == '\0') { DOUBLE_TO_NPVARIANT(doubleResult, *result); return; } } // Return string STRINGN_TO_NPVARIANT(res, (uint32_t)strlen(res), *result); return; }
//virtual void PluginMethodListenOnFile::OnError(const char* message, unsigned int len) { NPVariant args[2]; NPVariant ret_val; BOOLEAN_TO_NPVARIANT( false, args[0]); STRINGN_TO_NPVARIANT( message, len, args[1]); // fire callback NPN_InvokeDefault( npp_, callback_, args, 2, &ret_val); NPN_ReleaseVariantValue(&ret_val); }
bool CJSMethods::OpenUrl(wstring strUrl) { if(m_pScriptableObject == NULL) { return false; } NPP pluginInstance = m_pScriptableObject->GetPluginInstance(); NPNetscapeFuncs *pBrowserFuncs = m_pScriptableObject->GetBrowserFuncs(); if(pluginInstance == NULL || pBrowserFuncs == NULL) { return false; } NPVariant varResults; char *pszUrl = new char[strUrl.size() + 4]; int nConverted = WideCharToMultiByte(CP_ACP, 0, strUrl.c_str(), strUrl.size(), pszUrl, strUrl.size() + 1, NULL, NULL); pszUrl[nConverted] = '\0'; NPVariant varArgs; STRINGN_TO_NPVARIANT(pszUrl, strlen(pszUrl), varArgs); bool bResult = CallJSMethod(pBrowserFuncs, pluginInstance, "openUrl", &varArgs, 1, varResults); // Dll will be crashed if you uncomment next line. // I don't know why, yet. //pBrowserFuncs->releasevariantvalue(&varArgs); pBrowserFuncs->releasevariantvalue(&varResults); delete [] pszUrl; return bResult; }
//lazy void _npapi_set_string(NPVariant *v, char *txt, int length) { char *t = (char *)npnfuncs->memalloc(length); strcpy(t, txt); STRINGN_TO_NPVARIANT(t, length, *v); }
bool NP_Invoke(NPObject* obj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result){ char * name = npnfuncs->utf8fromidentifier(methodName); if(strcmp(name, METHOD_TIME) == 0 && argCount > 0 && NPVARIANT_IS_STRING(args[0]) ){ char * filename = ArgToStr(args[0]); struct stat * buf = (struct stat *)malloc(sizeof(struct stat)); stat(filename, buf); free(filename); INT32_TO_NPVARIANT(buf->st_mtime, *result); free(buf); return true; }else if(strcmp(name, METHOD_GET) == 0 && argCount > 0 && NPVARIANT_IS_STRING(args[0]) ){ char * filename = ArgToStr(args[0]); //logmsg(filename); FILE * f = fopen(filename, "r"); if(f) { fseek(f, 0 , SEEK_END); long int size = ftell(f); rewind(f); char * buf = (char *)npnfuncs->memalloc(size); memset(buf, 0, size); fread(buf, 1, size, f); fclose(f); //logmsg(buf); STRINGN_TO_NPVARIANT(buf, size, *result); //npnfuncs->memfree(buf); } free(filename); return true; }else if(strcmp(name, METHOD_SET) == 0 && argCount > 1 && NPVARIANT_IS_STRING(args[0]) && NPVARIANT_IS_STRING(args[1]) ){ char * filename = ArgToStr(args[0]); char * content = ArgToStr(args[1]); FILE * f = fopen(filename, "w"); bool succ = false; if(f) { fputs(content, f); succ = ferror(f) == 0; fclose(f); } free(filename); free(content); BOOLEAN_TO_NPVARIANT(succ, *result); return true; } return false; }