plugin/npapi/gshell.cpp

   1 //
   2 //   Copyright (C) 2010, 2011 Free Software Foundation, Inc
   3 //
   4 // This program is free software; you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation; either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should hxave received a copy of the GNU General Public License
  15 // along with this program; if not, write to the Free Software
  16 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 //
  18
  19 #include <iostream>
  20 #include <string>
  21 #include <cstdlib>
  22 #include <vector>
  23 #include <map>
  24 #include <cassert>
  25
  26 #include "npapi.h"
  27 #include "npruntime.h"
  28 #include "npfunctions.h"
  29 #include "plugin.h"
  30 #include "pluginbase.h"
  31 #include <regex.h>
  32
  33 #include "external.h"
  34 #include "dsodefs.h" // DSOEXPORT
  35
  36 #ifdef _WIN32
  37 #undef DLL_EXPORT
  38 #define LIBLTDL_DLL_IMPORT 1
  39 #endif
  40
  41 #include <sys/param.h>
  42 #include <ltdl.h>
  43
  44 using namespace gnash;
  45 using namespace std;
  46
  47 typedef NPError NP_InitializePtr (NPNetscapeFuncs* aNPNFuncs,
  48                                   NPPluginFuncs* aNPPFuncs);
  49
  50 extern NPError NS_PluginGetValue(NPPVariable aVariable, void *aValue);
  51
  52 // This is a global variable commonly used by plugins to access
  53 // the browser's function table. Since we aren't using a browser
  54 // we have to populate this ourselves.
  55 NPNetscapeFuncs *
  56 populateNPFuncs(NPNetscapeFuncs *aNPNFuncs)
  57 {
  58     aNPNFuncs->size = 45;       // this is the count of entries
  59     aNPNFuncs->version = 1.9;
  60
  61     aNPNFuncs->geturl = NPN_GetURL;
  62     aNPNFuncs->posturl = NPN_PostURL;
  63     aNPNFuncs->requestread = NPN_RequestRead;
  64     aNPNFuncs->newstream = NPN_NewStream;
  65     aNPNFuncs->write = NPN_Write;
  66     aNPNFuncs->destroystream = NPN_DestroyStream;
  67     aNPNFuncs->status = NPN_Status;
  68     aNPNFuncs->uagent = NPN_UserAgent;
  69     aNPNFuncs->memalloc = NPN_MemAlloc;
  70     aNPNFuncs->memfree = NPN_MemFree;
  71     aNPNFuncs->memflush = NPN_MemFlush;
  72     aNPNFuncs->reloadplugins = NPN_ReloadPlugins;
  73     aNPNFuncs->getJavaEnv = 0;    // NPN_GetJavaEnv;
  74     aNPNFuncs->getJavaPeer = 0;   //NPN_GetJavaPeer;
  75     aNPNFuncs->geturlnotify = NPN_GetURLNotify;
  76     aNPNFuncs->posturlnotify = NPN_PostURLNotify;
  77     aNPNFuncs->getvalue = NPN_GetValue;
  78     aNPNFuncs->setvalue = NPN_SetValue;
  79     aNPNFuncs->invalidaterect = NPN_InvalidateRect;
  80     aNPNFuncs->invalidateregion = NPN_InvalidateRegion;
  81     aNPNFuncs->forceredraw = 0;    // NPN_ForceDraw;
  82     aNPNFuncs->getstringidentifier = NPN_GetStringIdentifier;
  83     aNPNFuncs->getstringidentifiers = NPN_GetStringIdentifiers;
  84     aNPNFuncs->getintidentifier = NPN_GetIntIdentifier;
  85     aNPNFuncs->identifierisstring = NPN_IdentifierIsString;
  86     aNPNFuncs->utf8fromidentifier = NPN_UTF8FromIdentifier;
  87     aNPNFuncs->intfromidentifier = NPN_IntFromIdentifier;
  88     aNPNFuncs->createobject = NPN_CreateObject;
  89     aNPNFuncs->retainobject = NPN_RetainObject;
  90     aNPNFuncs->releaseobject = NPN_ReleaseObject;
  91     aNPNFuncs->invoke = NPN_Invoke;
  92     aNPNFuncs->invokeDefault = NPN_InvokeDefault;
  93     aNPNFuncs->evaluate = NPN_Evaluate;
  94     aNPNFuncs->getproperty = NPN_GetProperty;
  95     aNPNFuncs->setproperty = NPN_SetProperty;
  96     aNPNFuncs->removeproperty = NPN_RemoveProperty;
  97     aNPNFuncs->hasproperty = NPN_HasProperty;
  98     aNPNFuncs->hasmethod = NPN_HasMethod;
  99     aNPNFuncs->releasevariantvalue = NPN_ReleaseVariantValue;
 100     aNPNFuncs->setexception = NPN_SetException;
 101     // aaNPNFuncs->pushpopupsenabledstate = NPN_PushPopupsEnabledState;
 102     // aaNPNFuncs->poppopupsenabledstate = NPN_PopPopupsEnabledState;
 103     aNPNFuncs->enumerate = NPN_Enumerate;
 104     aNPNFuncs->pluginthreadasynccall = NPN_PluginThreadAsyncCall;
 105     aNPNFuncs->construct = NPN_Construct;
 106     // aNPNFuncs->getvalueforurl = NPN_GetValueForURL;
 107     // aNPNFuncs->setvalueforurl = NPN_SetValueForURL;
 108
 109     return aNPNFuncs;
 110 }
 111
 112 int
 113 main(int argc, char *argv[])
 114 {
 115     // Initialize libtool's dynamic library loader
 116     int errors = lt_dlinit ();
 117     if (errors) {
 118         cerr << "ERROR: Couldn't initialize ltdl: " << lt_dlerror() << endl;
 119     }
 120
 121     // load a plugin in the current directory
 122     string plugindir = ".";
 123
 124     //
 125     char dir[MAXPATHLEN];
 126     getcwd(dir, MAXPATHLEN);
 127     plugindir += ":";
 128     plugindir += dir;
 129     plugindir += "/.libs/";
 130 //    plugindir += "/plugin/npapo/.libs";
 131
 132     lt_dlsetsearchpath(plugindir.c_str());
 133
 134     string filespec = "libgnashplugin.so";
 135     lt_dlhandle handle;
 136     handle = lt_dlopenext (filespec.c_str());
 137
 138     if (handle == NULL) {
 139         cerr << lt_dlerror() << endl;
 140         return false;
 141     }
 142     // Make this module unloadable
 143     lt_dlmakeresident(handle);
 144
 145     // Get the init function
 146     lt_ptr run = NULL;
 147     string symbol = "NP_Initialize"; // NS_PluginInitialize instead ?
 148     run  = lt_dlsym (handle, symbol.c_str());
 149
 150     if (run == NULL) {
 151         cout << "Couldn't find symbol: " << symbol << endl;
 152         return NULL;
 153     } else {
 154         cout << "Found symbol " << symbol << " @ " << hex << run << endl;
 155     }
 156
 157     // this gets populated by the browser
 158     NPNetscapeFuncs aNPNFuncs;
 159     populateNPFuncs(&aNPNFuncs);
 160
 161     // this gets populated by the plugin
 162     //NPPluginFuncs *aNPPFuncs;
 163     nsPluginCreateData ds;
 164
 165     // NPPFuncs.newp(NPMIMEType, 0, 0, 1, 0, "foo", 0);
 166     // nsPluginInstanceBase * plugin = NS_NewPluginInstance(&ds);
 167
 168     NPPluginFuncs *aNPPFuncs = 0;
 169     // Execute the plugin's initialization function
 170     NP_InitializePtr *ptr = (NP_InitializePtr *)run;
 171     NPError error = ptr(&aNPNFuncs, aNPPFuncs);
 172     //    cout << getPluginDescription() << endl;
 173
 174     char *str = 0;
 175     NPP_GetValue(0, NPPVpluginDescriptionString, str);
 176     if (str) {
 177         cerr << str << endl;
 178     }
 179
 180     bool bo = false;
 181     NPN_GetValue(0, NPNVSupportsXEmbedBool, &bo);
 182     cerr << bo << endl;
 183 }
 184
 185 // We have to implement these two memory allocation functions as
 186 // they're used in the code we're testing.
 187 void *
 188 NPN_MemAlloc(uint32_t size)
 189 {
 190   void * rv = NULL;
 191   rv = malloc(size);
 192   return rv;
 193 }
 194
 195 void
 196 NPN_MemFree(void* ptr)
 197 {
 198   assert(ptr);
 199   free(ptr);
 200 }
 201
 202 uint32_t
 203 NPN_MemFlush(uint32_t size)
 204 {
 205     return size;
 206 }
 207
 208 NPUTF8 *
 209 NPN_UTF8FromIdentifier(NPIdentifier identifier)
 210 {
 211     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 212 }
 213
 214 int32_t
 215 NPN_IntFromIdentifier(NPIdentifier identifier)
 216 {
 217     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 218 }
 219
 220 // These are just stubs to get the test case to link standalone.
 221 NPIdentifier
 222 NPN_GetStringIdentifier(const NPUTF8 *name)
 223 {
 224     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 225 }
 226
 227 NPError
 228 NPP_GetValue(NPP instance, NPPVariable aVariable, void *aValue)
 229 {
 230     if (NPPFuncs.getvalue) {
 231         return NPPFuncs.getvalue(instance, aVariable, aValue);
 232     }
 233     return NPERR_GENERIC_ERROR;
 234 }
 235
 236 NPError
 237 NPN_GetURLNotify(NPP instance, const char* url,
 238                  const char* target, void* notifyData)
 239 {
 240     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 241 }
 242
 243 NPError
 244 NPN_PostURLNotify(NPP instance, const char* url,
 245                   const char* target, uint32_t len,
 246                   const char* buf, NPBool file,
 247                   void* notifyData)
 248 {
 249     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 250 }
 251
 252 bool
 253 NPN_Invoke(NPP npp, NPObject *npobj, NPIdentifier methodName,
 254            const NPVariant *args, uint32_t argCount, NPVariant *result)
 255 {
 256     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 257 }
 258
 259 bool
 260 NPN_InvokeDefault(NPP npp, NPObject *npobj, const NPVariant *args,
 261                   uint32_t argCount, NPVariant *result)
 262 {
 263     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 264 }
 265
 266 bool
 267 NPN_Evaluate(NPP npp, NPObject *npobj, NPString *script,
 268              NPVariant *result)
 269 {
 270     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 271 }
 272
 273 bool
 274 NPN_GetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName,
 275                 NPVariant *result)
 276 {
 277     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 278 }
 279
 280 bool
 281 NPN_HasProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName)
 282 {
 283     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 284 }
 285
 286 bool
 287 NPN_HasMethod(NPP npp, NPObject *npobj, NPIdentifier methodName)
 288 {
 289     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 290 }
 291
 292 NPError
 293 NPN_GetValue(NPP instance, NPNVariable aVariable, void *aValue)
 294 {
 295     if (NPPFuncs.getvalue) {
 296         return NPNFuncs.getvalue(instance, aVariable, aValue);
 297     }
 298     return NPERR_GENERIC_ERROR;
 299 }
 300
 301 NPError
 302 NPN_SetValue(NPP instance, NPPVariable aVariable, void *aValue)
 303 {
 304     if (NPPFuncs.setvalue) {
 305         return NPNFuncs.setvalue(instance, aVariable, aValue);
 306     }
 307     return NPERR_GENERIC_ERROR;
 308 }
 309
 310 void
 311 NPN_InvalidateRect(NPP instance, NPRect *invalidRect)
 312 {
 313     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 314 }
 315
 316 void
 317 NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion)
 318 {
 319     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 320 }
 321
 322 void
 323 NPN_ReloadPlugins(NPBool reloadPages)
 324 {
 325     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 326 }
 327
 328 NPError
 329 NPN_GetURL(NPP instance, const char* url, const char* target)
 330 {
 331     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 332 }
 333
 334 NPError
 335 NP_LOADDS NPN_PostURL(NPP instance, const char* url,
 336                       const char* target, uint32_t len,
 337                       const char* buf, NPBool file)
 338 {
 339     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 340 }
 341
 342 NPError
 343 NPN_RequestRead(NPStream* stream, NPByteRange* rangeList)
 344 {
 345     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 346 }
 347
 348 NPError
 349 NPN_NewStream(NPP instance, NPMIMEType type, const char* target,
 350               NPStream** stream)
 351 {
 352     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 353 }
 354
 355 void
 356 NPN_Status(NPP instance, const char* message)
 357 {
 358     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 359 }
 360
 361 const char *
 362 NPN_UserAgent(NPP instance)
 363 {
 364     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 365 }
 366
 367 int32_t
 368 NPN_Write(NPP instance, NPStream* stream, int32_t len, void* buffer)
 369 {
 370     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 371 }
 372
 373 NPError
 374 NPN_DestroyStream(NPP instance, NPStream* stream, NPReason reason)
 375 {
 376     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 377 }
 378
 379 void
 380 NS_PluginShutdown()
 381 {
 382     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 383 }
 384
 385 char*
 386 NPP_GetMIMEDescription(void)
 387 {
 388     char *x = 0;
 389     return x;
 390 }
 391
 392 void
 393 NS_DestroyPluginInstance(nsPluginInstanceBase *aPlugin)
 394 {
 395     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 396 }
 397
 398 std::map<NPIdentifier, NPVariant *> _properties;
 399 std::map<NPIdentifier,  NPInvokeFunctionPtr> _methods;
 400
 401 // Implement minimal properties handling
 402 bool
 403 NPN_SetProperty(NPP npp, NPObject* obj, NPIdentifier name,
 404                      const NPVariant *value)
 405 {
 406     _properties[name] = const_cast<NPVariant *>(value);
 407 }
 408
 409 bool
 410 NPN_GetProperty(NPP npp, NPObject* obj, NPIdentifier name,
 411                      const NPVariant *value)
 412 {
 413     return _properties[name];
 414 }
 415
 416 bool
 417 NPN_RemoveProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName)
 418 {
 419     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 420 }
 421
 422 bool
 423 NPN_HasProperty(NPP npp, NPObject* obj, NPIdentifier name,
 424                      const NPVariant *value)
 425 {
 426     std::map<NPIdentifier, NPVariant *>::iterator it;
 427     it = _properties.find(name);
 428     if (it != _properties.end()) {
 429         return true;
 430     }
 431 }
 432
 433
 434 void
 435 NPN_SetException(NPObject *npobj, const NPUTF8 *message)
 436 {
 437     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 438 }
 439
 440 void
 441 NPN_PluginThreadAsyncCall(NPP plugin, void (*func)(void *), void *userData)
 442 {
 443     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 444 }
 445
 446 bool
 447 NPN_Enumerate(NPP npp, NPObject *npobj, NPIdentifier **identifier,
 448               uint32_t *count)
 449 {
 450     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 451 }
 452
 453 bool
 454 NPN_Construct(NPP npp, NPObject *npobj, const NPVariant *args,
 455               uint32_t argCount, NPVariant *result)
 456 {
 457     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 458 }
 459
 460 void
 461 NPN_ReleaseVariantValue(NPVariant *variant)
 462 {
 463     switch(variant->type) {
 464         case NPVariantType_String:
 465         {
 466             NPN_MemFree(const_cast<NPUTF8*>(NPVARIANT_TO_STRING(*variant).UTF8Characters));
 467             break;
 468         }
 469         case NPVariantType_Object:
 470         {
 471             NPObject* obj = NPVARIANT_TO_OBJECT(*variant);
 472             if (obj) {
 473                 NPN_ReleaseObject(obj);
 474             }
 475             break;
 476         }
 477         default:
 478         {}
 479     }
 480
 481     NULL_TO_NPVARIANT(*variant);
 482 }
 483
 484 NPObject *
 485 NPN_CreateObject(NPP npp, NPClass *aClass)
 486 {
 487     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 488 }
 489
 490 void
 491 NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount,
 492                          NPIdentifier *identifiers)
 493 {
 494     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 495 }
 496
 497 NPIdentifier
 498 NPN_GetIntIdentifier(int32_t intid)
 499 {
 500     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 501 }
 502
 503 bool
 504 NPN_IdentifierIsString(NPIdentifier identifier)
 505 {
 506     cerr << "UNIMPLEMENTED: " << __PRETTY_FUNCTION__ << endl;
 507 }
 508
 509 NPObject*
 510 NPN_RetainObject(NPObject *obj)
 511 {
 512     assert(obj); ++obj->referenceCount; return obj;
 513 }
 514
 515 void
 516 NPN_ReleaseObject(NPObject *npobj)
 517 {
 518     assert(npobj);
 519     --npobj->referenceCount;
 520     if (npobj->referenceCount == 0) {
 521         NPN_MemFree(npobj);
 522     }
 523 }
 524 // Local Variables:
 525 // mode: C++
 526 // indent-tabs-mode: nil
 527 // End: