コード例 #1
0
static NPError
post_data(NPP instance, const char *url, const char *target, uint32 len,
	  const char *buf, const char *tag)
{
	NPError rv;
	char headers[256], *sendbuf;
	char *content;
	unsigned int content_len, hdrlen, taglen;
	
	taglen = strlen(tag);
	content_len = taglen + len + 1;
	content = (char *) NPN_MemAlloc(content_len);
	if (content == NULL)
		return NPERR_OUT_OF_MEMORY_ERROR;
	memcpy(content, tag, taglen);
	content[taglen] = '=';
	memcpy(content+taglen+1, buf, len);
	
	sprintf(headers, "Content-type: application/x-www-form-urlencoded\r\n"
			 "Content-Length: %u\r\n\r\n", (unsigned int) content_len);
	hdrlen = strlen(headers);
	sendbuf = (char *) NPN_MemAlloc(hdrlen + content_len);
	if (sendbuf == NULL)
		return NPERR_OUT_OF_MEMORY_ERROR;
	memcpy(sendbuf, headers, hdrlen);
	memcpy(sendbuf + hdrlen, content, content_len);
	sendbuf[hdrlen + content_len] = 0;
	NPN_MemFree(content);
	printf("Sending:\n---\n%s---\n", sendbuf);
	printf("Url: '%s', target: '%s', len: %ld\n", url, target, hdrlen + len);
	rv = NPN_PostURL(instance, url, target, hdrlen + content_len, sendbuf, FALSE);

	return rv;
}
コード例 #2
0
CPluginInstancePeer::CPluginInstancePeer(NPP npp,
                                         nsMIMEType typeString, 
                                         nsPluginMode type,
                                         PRUint16 attr_cnt, 
                                         const char** attr_list, 
                                         const char** val_list)
    : npp(npp), typeString(typeString), type(type), attribute_cnt((PRUint16)NULL),
    attribute_list(NULL), values_list(NULL)
{
    // Set the reference count to 0.
    NS_INIT_REFCNT();

	attribute_list = (char**) NPN_MemAlloc(attr_cnt * sizeof(const char*));
	values_list = (char**) NPN_MemAlloc(attr_cnt * sizeof(const char*));

	if (attribute_list != NULL && values_list != NULL) {
		for (int i = 0, j = 0; i < attr_cnt; i++)   {
            if (attr_list[i] != NULL && val_list[i] != NULL) {           
                
                attribute_list[j] = (char*) NPN_MemAlloc(strlen(attr_list[i]) + 1);
                if (attribute_list[j] != NULL)
                    strcpy(attribute_list[j], attr_list[i]);

                values_list[j] = (char*) NPN_MemAlloc(strlen(val_list[i]) + 1);
                if (values_list[j] != NULL)
                    strcpy(values_list[j], val_list[i]);

                j = j + 1;
                attribute_cnt = j;
            }
		}
	}
}
コード例 #3
0
//-----------------------------------------------------------------------------
// NPP_Destroy:
//-----------------------------------------------------------------------------
NPError NP_LOADDS
NPP_Destroy(NPP instance, NPSavedData** save) {
  if ( instance == 0 ) return NPERR_INVALID_INSTANCE_ERROR;

  PluginInstance* This = (PluginInstance*) instance->pdata;

  //
  // *Developers*: If desired, call NP_MemAlloc to create a
  // NPSavedDate structure containing any state information
  // that you want restored if this plugin instance is later
  // recreated.
  //

  if ( This ) {
    // destroy hmf and PS
    if ( This->hmf ) GpiDeleteMetaFile( This->hmf );
    if ( This->hps ) GpiDestroyPS( This->hps );
    // delete buffer
    if ( This->bufMeta ) {
      free( This->bufMeta );
      This->bufMeta=NULL;
      This->cbMeta=0;
      This->offMeta=0;
    }
    // Remove the subclass for the client window
    if ( This->hWnd ) WinSubclassWindow( This->hWnd, This->lpfnOldWndProc );
    // make some saved instance data if necessary
    if ( This->pSavedInstanceData == 0 ) {
      // make a struct header for the data
      This->pSavedInstanceData =
          (NPSavedData*)NPN_MemAlloc(sizeof (struct _NPSavedData));
      // fill in the struct
      if ( This->pSavedInstanceData != 0 ) {
        This->pSavedInstanceData->len = 0;
        This->pSavedInstanceData->buf = 0;

        // replace the def below and references to it with your data
        #define SIDATA "aSavedInstanceDataBlock"

        // the data
        This->pSavedInstanceData->buf = NPN_MemAlloc(sizeof SIDATA);

        if( This->pSavedInstanceData->buf ) {
          strcpy((char*)This->pSavedInstanceData->buf, SIDATA);
          This->pSavedInstanceData->len = sizeof SIDATA;
        }
      }
    }

    // save some instance data
    *save = This->pSavedInstanceData;

    NPN_MemFree(instance->pdata);
    instance->pdata = 0;
  }
  return NPERR_NO_ERROR;
}
コード例 #4
0
ファイル: nullplugin.c プロジェクト: amyvmiwei/firefox
/* callback function for the OK button */
static void 
DialogOKClicked (GtkButton *button, gpointer data)
{
    PluginInstance* This = (PluginInstance*) data;
    GtkWidget* dialogWindow = g_object_get_data(GTK_OBJECT(button), DIALOGID);
    char *url;

    g_object_set_data(GTK_OBJECT(button), DIALOGID, NULL);

    if (This->pluginsFileUrl != NULL)
    {
        /* Get the JavaScript command string */
        static const char buf[] = 
          "javascript:netscape.softupdate.Trigger.StartSoftwareUpdate(\"%s\")";

        url = NPN_MemAlloc(strlen(This->pluginsFileUrl) + (sizeof(buf) - 2));
        if (url != NULL)
        {
            /* Insert the file URL into the JavaScript command */
            sprintf(url, buf, This->pluginsFileUrl);
            NPN_GetURL(This->instance, url, TARGET);
            NPN_MemFree(url);
        }
    }
    else
    {
        /* If necessary, get the default plug-ins page resource */
        char* address = This->pluginsPageUrl;
        if (address == NULL || *address == 0)
        {
            address = PLUGINSPAGE_URL;
        }

        url = NPN_MemAlloc(strlen(address) + 1 + strlen(This->type)+1);
        if (url != NULL)
        {
            NPN_PushPopupsEnabledState(This->instance, TRUE);
                /* Append the MIME type to the URL */
            sprintf(url, "%s?%s", address, This->type);
            if (strcmp (This->type, JVM_MINETYPE) == 0) 
            {
                NPN_GetURL(This->instance, JVM_SMARTUPDATE_URL , TARGET);
            }
            else 
            {
                NPN_GetURL(This->instance, url, TARGET);
            }
            NPN_MemFree(url);
            NPN_PopPopupsEnabledState(This->instance);
        }
    }
    destroyWidget(This);
}
コード例 #5
0
ファイル: npsqueak.c プロジェクト: fniephaus/squeak
static void
PostUrl(SqueakPlugin *plugin)
{
  char *url, *target, *data;
  int id, urlSize, targetSize, dataSize;

  errno= 0;
  Receive(plugin, &id, 4);
  /* Read URL from pipe */
  Receive(plugin, &urlSize, 4);
  if (urlSize > 0) {
    url= NPN_MemAlloc(urlSize+1);
    Receive(plugin, url, urlSize);
    url[urlSize]= 0;
  } else url= NULL;
  /* Read target from pipe */
  Receive(plugin, &targetSize, 4);
  if (targetSize > 0) {
    target= NPN_MemAlloc(targetSize+1);
    Receive(plugin, target, targetSize);
    target[targetSize]= 0;
  } else target= NULL;
  /* Read post data from pipe */
  Receive(plugin, &dataSize, 4);
  if (dataSize > 0) {
    data= NPN_MemAlloc(dataSize);
    Receive(plugin, data, dataSize);
  } else data= NULL;

  if (errno) {
    perror("Squeak Plugin (PostUrl)");
  } else {
    SqueakStream* notifyData= 
      (SqueakStream*) NPN_MemAlloc(sizeof(SqueakStream));
    if (!notifyData) { 
      fprintf(stderr, "Squeak Plugin (PostUrl): alloc failed\n");
    } else {
      DPRINT("NP: PostURLNotify(%s, id=%i)\n", url, id);
      notifyData->id= id;
      NPN_PostURLNotify(plugin->instance, url, target, 
			dataSize, data, FALSE, notifyData);
    }
  }

  if (url) NPN_MemFree(url);
  if (target) NPN_MemFree(target);
  if (data) NPN_MemFree(data);
}
コード例 #6
0
ファイル: npsqueak.c プロジェクト: fniephaus/squeak
static void
GetUrl(SqueakPlugin *plugin)
{
  char *url, *target;
  int id, urlSize, targetSize;

  errno= 0;
  Receive(plugin, &id, 4);
  /* Read URL from pipe */
  Receive(plugin, &urlSize, 4);
  if (urlSize > 0) {
    url= NPN_MemAlloc(urlSize+1);
    Receive(plugin, url, urlSize);
    url[urlSize]= 0;
  } else url= NULL;
  /* Read target from pipe */
  Receive(plugin, &targetSize, 4);
  if (targetSize > 0) {
    target= NPN_MemAlloc(targetSize+1);
    Receive(plugin, target, targetSize);
    target[targetSize]= 0;
  } else target= NULL;

  if (errno) {
    perror("Squeak Plugin (GetUrl)");
  } else {
    DPRINT("NP: GetUrl(%s, %s)\n", url, target ? target : "NULL");
    if (strcmp(url, plugin->srcUrl)==0) {
      if (plugin->srcFilename)
	DeliverFile(plugin, id, plugin->srcFilename);
      else
	plugin->srcId= id;
    } else {
      SqueakStream* notifyData= 
	(SqueakStream*) NPN_MemAlloc(sizeof(SqueakStream));
      if (!notifyData) { 
	fprintf(stderr, "Squeak Plugin (GetUrl): alloc failed\n");
      } else {
	DPRINT("NP: GetURLNotify(%s, id=%i)\n", url, id);
	notifyData->id= id;
	NPN_GetURLNotify(plugin->instance, url, target, notifyData);
      }
    }
  }

  if (url) NPN_MemFree(url);
  if (target) NPN_MemFree(target);
}
コード例 #7
0
ファイル: plugin.cpp プロジェクト: AsherBond/DimSim
// ==============================
// ! Scriptability related code !
// ==============================
//
// here the plugin is asked by Mozilla to tell if it is scriptable
// we should return a valid interface id and a pointer to 
// nsScriptablePeer interface which we should have implemented
// and which should be defined in the corressponding *.xpt file
// in the bin/components folder
NPError	nsPluginInstance::GetValue(NPPVariable aVariable, void *aValue)
{
	NPError rv = NPERR_NO_ERROR;

	switch (aVariable) {
	case NPPVpluginScriptableInstance: {
		// addref happens in getter, so we don't addref here
		nsIDimdimControl * scriptablePeer = getScriptablePeer();
		if (scriptablePeer) {
			*(nsISupports **)aValue = scriptablePeer;
		} else
			rv = NPERR_OUT_OF_MEMORY_ERROR;
									   }
									   break;

	case NPPVpluginScriptableIID: {
		static nsIID scriptableIID = NS_IDIMDIMCONTROL_IID;
		nsIID* ptr = (nsIID *)NPN_MemAlloc(sizeof(nsIID));
		if (ptr) {
			*ptr = scriptableIID;
			*(nsIID **)aValue = ptr;
		} else
			rv = NPERR_OUT_OF_MEMORY_ERROR;
								  }
								  break;

	default:
		break;
	}

	return rv;
}
コード例 #8
0
NPError 
NPP_Destroy(NPP instance, NPSavedData** save)
{
//    TRACE("NPP_Destroy\n");
    
    if (instance == NULL)
        return NPERR_INVALID_INSTANCE_ERROR;
    
    nsIPluginInstance* pluginInstance = (nsIPluginInstance* )instance->pdata;
	IUniqueIdentifier* pInst = NULL;
	if(NS_SUCCEEDED(pluginInstance->QueryInterface(kIUniqueIdentifierIID, (void**)&pInst))) {
		*save = (NPSavedData*)NPN_MemAlloc(sizeof(NPSavedData));
		long id;

		pInst->GetUniqueId(&id);
		(*save)->buf = NULL;
		(*save)->len = id;
		pInst->Release();
	}

    pluginInstance->Stop();
    pluginInstance->Destroy();
    pluginInstance->Release();
    instance->pdata = NULL;
    
    return NPERR_NO_ERROR;
}
コード例 #9
0
ファイル: plugin.cpp プロジェクト: xgc820313/js2n
bool
ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args,
                               uint32_t argCount, NPVariant *result)
{
  if (name == sendCmd_id)
  {
	if ( argCount < 1 )
	{
		return false;
	}

	PString strParam = "";
	NPString npStr = NPVARIANT_TO_STRING( args[0] );
	for (unsigned int i=0; i<npStr.utf8length; i++)
	{
		strParam += npStr.utf8characters[ i ];
	}


	PString strResult = g_NativeLogic.InvokeFunction( strParam );

	char* pszName = (char*)NPN_MemAlloc( strResult.GetSize() + 1 );
	strcpy( pszName, strResult );
    STRINGZ_TO_NPVARIANT(pszName, *result);

    return PR_TRUE;
  }

  return PR_FALSE;
}
コード例 #10
0
ファイル: mrb_js.cpp プロジェクト: guofei/JsMruby
static mrb_value mrb_js_obj_get(mrb_state *mrb, mrb_value klass)
{
    mrb_value str;
    mrb_get_args(mrb, "S", &str);

    NPObject *window;
    NPN_GetValue(MRB_UD_NPP(mrb), NPNVWindowNPObject, &window);

    NPUTF8 *s = (NPUTF8 *)NPN_MemAlloc(RSTRING_LEN(str));
    std::copy(RSTRING_PTR(str), RSTRING_END(str), s);
    NPString evaluated_str = { s, RSTRING_LEN(str) };

    NPVariant result;
    std::string js_str(RSTRING_PTR(str), RSTRING_LEN(str));
    NPN_Evaluate(MRB_UD_NPP(mrb), window, &evaluated_str, &result);
    NPN_ReleaseObject(window);
    NPN_MemFree(s);

    mrb_value ret;
    if (!convert_js_to_mrb(MRB_UD_NPP(mrb), result, mrb, &ret)){
        return mrb_nil_value();
    }

    return ret;
}
コード例 #11
0
/** 
 * Custom allocation of memory.
 * Stub for future use.
 * 
 * @param plugin - Parent plugin
 * @param aClass - Plugin class
 * @return JS Object
 */
static NPObject* 
jsInterface_Allocate (NPP plugin, NPClass *aClass)
{
    jsInterfaceObject *object;
    object = (jsInterfaceObject*) NPN_MemAlloc(sizeof(jsInterfaceObject));
    return (NPObject*) object;
}
コード例 #12
0
ファイル: plugin.cpp プロジェクト: jjfsq1985/StudyLab
void CPlugin::getVersion(char* *aVersion)
{
    const char *ua = NPN_UserAgent(m_pNPInstance);
    char*& version = *aVersion;
    version = (char*)NPN_MemAlloc(1 + strlen(ua));
    if (version)
        strcpy(version, ua);
}
コード例 #13
0
ファイル: nullplugin.c プロジェクト: amyvmiwei/firefox
NPMIMEType
dupMimeType(NPMIMEType type)
{
    NPMIMEType mimetype = NPN_MemAlloc(strlen(type)+1);
    if (mimetype)
        strcpy(mimetype, type);
    return(mimetype);
}
コード例 #14
0
ファイル: npshell.c プロジェクト: binoc-software/mozilla-cvs
NPError 
NPP_New(NPMIMEType pluginType,
    NPP instance,
    uint16 mode,
    int16 argc,
    char* argn[],
    char* argv[],
    NPSavedData* saved)
{

    PluginInstance* This;

    if (instance == NULL)
        return NPERR_INVALID_INSTANCE_ERROR;
        
    instance->pdata = NPN_MemAlloc(sizeof(PluginInstance));
    
    This = (PluginInstance*) instance->pdata;

    if (This == NULL) 
    {
        return NPERR_OUT_OF_MEMORY_ERROR;
    }

    memset(This, 0, sizeof(PluginInstance));

    /* mode is NP_EMBED, NP_FULL, or NP_BACKGROUND (see npapi.h) */
    This->mode = mode;
    This->type = dupMimeType(pluginType);
    This->instance = instance;
    This->pluginsPageUrl = NULL;
    This->exists = FALSE;

    /* Parse argument list passed to plugin instance */
    /* We are interested in these arguments
     *  PLUGINSPAGE = <url>
     */
    while (argc > 0)
    {
        argc --;
        if (argv[argc] != NULL)
        {
        if (!PL_strcasecmp(argn[argc], "PLUGINSPAGE"))
            This->pluginsPageUrl = strdup(argv[argc]);
        else if (!PL_strcasecmp(argn[argc], "PLUGINURL"))
            This->pluginsFileUrl = strdup(argv[argc]);
        else if (!PL_strcasecmp(argn[argc], "CODEBASE"))
            This->pluginsPageUrl = strdup(argv[argc]);
        else if (!PL_strcasecmp(argn[argc], "CLASSID"))
            This->pluginsFileUrl = strdup(argv[argc]);
        else if (!PL_strcasecmp(argn[argc], "HIDDEN"))
            This->pluginsHidden = (!PL_strcasecmp(argv[argc],
            "TRUE"));
        }
    }

    return NPERR_NO_ERROR;
}
コード例 #15
0
ファイル: plugin.cpp プロジェクト: zhsl2007/study
bool
ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result)
{
  VOID_TO_NPVARIANT(*result);

	//kk
  /*if (name == sBar_id) {
    static int a = 17;

    INT32_TO_NPVARIANT(a, *result);

    a += 5;

    return true;
  }*/
	char *pProp = NPN_UTF8FromIdentifier(name);
			
	if( !strcmp( "Version", pProp ) )
	{
		char *p = (char*) NPN_MemAlloc( "Version 1.0" );//allocating Memory for the string with invocation of Browser-API
		STRINGZ_TO_NPVARIANT( p, *result);
		return true;
	}

	if( !strcmp( "Name", pProp ) )
	{
		char *p = (char*) NPN_MemAlloc( m_pszName );//allocating Memory for the string with invocation of Browser-API
		STRINGZ_TO_NPVARIANT( p, *result);
		return true;
	}

  if (name == sPluginType_id) {
    NPObject *myobj =
      NPN_CreateObject(mNpp, GET_NPOBJECT_CLASS(ConstructablePluginObject));
    if (!myobj) {
      return false;
    }

    OBJECT_TO_NPVARIANT(myobj, *result);

    return true;
  }

  return true;
}
コード例 #16
0
ファイル: Plugin.cpp プロジェクト: Tao-Jing/npSafeInput
void CPlugin::getVersion(char* *aVersion)
{
    OutputDebugStringA("cplugin_getversion");
    const char *ua = NPN_UserAgent(m_pNPInstance);
    char*& version = *aVersion;
    version = (char*)NPN_MemAlloc(1 + strlen(ua));
    if (version)
        strcpy(version, ua);
}
コード例 #17
0
ファイル: fix.cpp プロジェクト: grharon/tpmbrowserplugin
char * m_strndup(const char *src, int len) {
	char *ret = NULL;
	if ((src) && (len >= 0)) {
		ret = (char*) NPN_MemAlloc(len+1);
		memcpy(ret, src, len);
		ret[len] = '\0';
	}
	return ret;
}
コード例 #18
0
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;
    }
}
コード例 #19
0
ファイル: snapshot.c プロジェクト: meh/npapi-mumble-link
NPObject*
Snapshot_Allocate (NPP plugin, NPClass* klass)
{
	Mumble* self = (Mumble*) Mumble_Get(PA_Self(plugin));
	Mumble* copy = (Mumble*) NPN_MemAlloc(sizeof(Mumble));

	memcpy(copy, self, sizeof(Mumble));

	return PA_Object(klass, plugin, copy);
}
コード例 #20
0
ファイル: plugin.cpp プロジェクト: zhsl2007/study
void* NPN_MemAlloc(LPCTSTR psz)
{
	int size = strlen( psz );

	void * rv = NPN_MemAlloc(size);

	strcpy( (char*) rv, psz );

	return rv;
}
コード例 #21
0
	native_Blender3DPlugin_SendMessage(
		JRIEnv* env, 
		Blender3DPlugin* self,
		struct java_lang_String * to,
		struct java_lang_String * from,
		struct java_lang_String * subject,
		struct java_lang_String * body
		)
{
	
	NPP npp = (NPP)netscape_plugin_Plugin_getPeer(env, self);
	BlenderPluginInstance* inst  = NULL;
	char *to_p, *from_p, *subject_p, *body_p;

	B3D_log_entry("native_Blender3DPlugin_SendMessage");

	inst = (BlenderPluginInstance*) npp->pdata;

	fprintf(stderr, "Doing java stuff for instance %p\n",
		inst);
	fflush(stderr);
	
	to_p = NPN_MemAlloc(JRI_GetStringUTFLength(env, to) + 1);
	from_p = NPN_MemAlloc(JRI_GetStringUTFLength(env, from) + 1);
	subject_p = NPN_MemAlloc(JRI_GetStringUTFLength(env, subject) + 1);
	body_p = NPN_MemAlloc(JRI_GetStringUTFLength(env, body) + 1);

	strcpy(to_p, JRI_GetStringUTFChars(env, to));
	strcpy(from_p, JRI_GetStringUTFChars(env, from));
	strcpy(subject_p, JRI_GetStringUTFChars(env, subject));
	strcpy(body_p, JRI_GetStringUTFChars(env, body));

	PLB_native_SendMessage_func(inst, 
				    to_p, 
				    from_p, 
				    subject_p, 
				    body_p);

	NPN_MemFree(to_p);
	NPN_MemFree(from_p);
	NPN_MemFree(subject_p);
	NPN_MemFree(body_p);
}
コード例 #22
0
char* CStringToNPStringCharacters(const CString &str)
{
	CStringW wstr = CT2W(str);
	int nUTF8 = WideCharToMultiByte(CP_UTF8, 0, wstr, wstr.GetLength() + 1, NULL, 0, NULL, NULL);
	if (nUTF8 == 0)
		return NULL;
	char* utf8str = (char *)NPN_MemAlloc(nUTF8);
	WideCharToMultiByte(CP_UTF8, 0, wstr, wstr.GetLength() + 1, utf8str, nUTF8, NULL, NULL);
	return utf8str;
}
コード例 #23
0
ファイル: NPPluginMisc.cpp プロジェクト: dulton/jorhy-prj
bool CNPPluginMisc::SetRetValue(char *psz_ret,NPVariant *result)
{
	int len = strlen(psz_ret);
	char *tmp = (char*)NPN_MemAlloc(len+1);
	strncpy(tmp,psz_ret,len);
	tmp[len] = '\0';
	STRINGZ_TO_NPVARIANT(tmp,*result);

	return true;
}
コード例 #24
0
NPError 
NPP_New(NPMIMEType pluginType,
	NPP instance,
	uint16 mode,
	int16 argc,
	char* argn[],
	char* argv[],
	NPSavedData* saved)
{
        PluginInstance* This;

	if (instance == NULL)
		return NPERR_INVALID_INSTANCE_ERROR;
		
	instance->pdata = NPN_MemAlloc(sizeof(PluginInstance));
	
	This = (PluginInstance*) instance->pdata;

	if (This != NULL)
	{
		/* mode is NP_EMBED, NP_FULL, or NP_BACKGROUND (see npapi.h) */
		This->mode = mode;
		This->window = (Window) 0;
		This->opmode = NP_NORMAL;
		This->nodata = FALSE;
#ifdef TEXT_PLUGIN
		This->form = 0;
		This->text = 0;
#endif /* TEXT_PLUGIN */
		while (argc > 0) {
			if (!strcasecmp(argn[argc-1], "MODE") && argv[argc-1]) {
			 	if (!strcasecmp(argv[argc-1], "seek"))
					This->opmode = NP_SEEK;
			 	if (!strcasecmp(argv[argc-1], "asfile"))
					This->opmode = NP_ASFILE;
			 	if (!strcasecmp(argv[argc-1], "asfileonly"))
					This->opmode = NP_ASFILEONLY;
			}
			else if (!strcasecmp(argn[argc-1], "NODATA"))
				This->nodata = TRUE;
			argc --;
		}

		/* PLUGIN DEVELOPERS:
		 *	Initialize fields of your plugin
		 *	instance data here.  If the NPSavedData is non-
		 *	NULL, you can use that data (returned by you from
		 *	NPP_Destroy to set up the new plugin instance).
		 */
		
		return NPERR_NO_ERROR;
	}
	else
		return NPERR_OUT_OF_MEMORY_ERROR;
}
コード例 #25
0
void* NPN_MemDup (const void* aMem, uint32 aLen)
{
  if (!aMem || !aLen)
    return NULL;

  void* dup = NPN_MemAlloc (aLen);
  if (!dup)
    return NULL;

  return memcpy (dup, aMem, aLen);
}
コード例 #26
0
// Type conversions
NPString NPString::fromQString(const QString &qstr)
{
    NPString npstring;
    const QByteArray qutf8 = qstr.toUtf8();

    npstring.utf8length = qutf8.length();
    npstring.utf8characters = (char*)NPN_MemAlloc(npstring.utf8length);
    memcpy((char*)npstring.utf8characters, qutf8.constData(), npstring.utf8length);

    return npstring;
}
コード例 #27
0
NS_IMETHODIMP
npAPInsIInputStreamShim::EnsureBuffer(int32 requestedAdditionalLen)
{

    // if we don't have a buffer, create one
    if (!mBuffer) {
        if (0 < INITIAL_BUFFER_LENGTH) {
            mBuffer = NPN_MemAlloc(INITIAL_BUFFER_LENGTH);
            mBufferLength = INITIAL_BUFFER_LENGTH;
        }
        if (!mBuffer) {
            mBufferLength = 0;
            return NS_ERROR_FAILURE;
        }
    }
    else {
        
        // See if we need to grow our buffer.  If what we have plus what
        // we're about to get is greater than the current buffer size...
        int32 additionalLen = requestedAdditionalLen < buffer_increment ?
            buffer_increment : requestedAdditionalLen;

        if (mBufferLength < (mCountFromPluginHost + additionalLen)) {
            // create the new buffer
            void *tBuffer = NPN_MemAlloc(mBufferLength + additionalLen);
            if (!tBuffer) {
                return NS_ERROR_FAILURE;
            }
            // copy the old buffer into the new buffer
            memcpy(tBuffer, mBuffer, mBufferLength);
            // delete the old buffer
            NPN_MemFree(mBuffer);
            // update mBuffer;
            mBuffer = tBuffer;
            // update our bufferLength
            mBufferLength += additionalLen;
        }
    }

    return NS_OK;
}
コード例 #28
0
ファイル: mrb_js.cpp プロジェクト: guofei/JsMruby
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;
}
コード例 #29
0
ファイル: fix.cpp プロジェクト: grharon/tpmbrowserplugin
char * m_strdup(const char *src) {
	char *ret = NULL;
	if (src) {
		int len = strlen(src);
		if (len >= 0) {
			ret = (char*) NPN_MemAlloc(len+1);
			memcpy(ret, src, len);
			ret[len] = '\0';
		}
	}
	return ret;
}
コード例 #30
0
ファイル: UnixShell.c プロジェクト: jinjoh/NOOR
void
execute_blenderplayer(BlenderPluginInstance* instance){

	char file_name[] = "/tmp/blender.XXXXXX";
	int fd = mkstemp(file_name);

	ssize_t real_size = write(fd, instance->main_file_store, instance->stream_retrieved);
	close(fd);

	instance->temp_mail_file_name = NPN_MemAlloc(strlen(file_name) + 1);
	strcpy(instance->temp_mail_file_name, file_name);

	instance->pID = fork();
	//XSelectInput(This->display , This->window, SubstructureNotifyMask);
	//XSync(This->display, FALSE);
	

#if defined(WITH_APPARMOR)
	const char* executable = "blenderplayer-web"; 
#elif defined(WITH_PRIVSEP)
	const char* executable = "blenderplayer-wrapper";
#else   
	const char* executable = "blenderplayer";
#endif

	if (instance->pID == 0) {              // child
		char window_id[50];
		sprintf(window_id, "%d", instance->window);
		//exit(0);
#ifdef WITH_PRIVSEP
		execlp(executable, executable, file_name, window_id, (char*)NULL);
#else 
		execlp(executable, executable, "-i", window_id, file_name, (char*)NULL);
#endif
	
	} else if (instance->pID < 0) {           // failed to fork
		printf("Failed to fork!!!\n");					
	}

	/*XEvent e;
	int started = 0;
	while(!started) {
		XNextEvent(This->display, &e);
		printf("Event type %d\n", e.type);					
		if (e.type == MapNotify) {
			started = 1;
			XCreateWindowEvent event =  e.xcreatewindow;
			printf("Created window x:%d, y: %d, h: %d, w: %d\n", event.x, event.y, event.height, event.width);
		}
	}*/

}