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;
}
