npunix.c
上传用户:hongyu5696
上传日期:2018-01-22
资源大小:391k
文件大小:11k
源码类别:

PlugIns编程

开发平台:

Unix_Linux

  1. /*
  2.  * npunix.c
  3.  *
  4.  * Netscape Client Plugin API
  5.  * - Wrapper function to interface with the Netscape Navigator
  6.  *
  7.  * dp Suresh <dp@netscape.com>
  8.  *
  9.  *----------------------------------------------------------------------
  10.  * PLUGIN DEVELOPERS:
  11.  * YOU WILL NOT NEED TO EDIT THIS FILE.
  12.  *----------------------------------------------------------------------
  13.  */
  14. #define XP_UNIX 1
  15. #include <stdio.h>
  16. #include "npapi.h"
  17. #include "npupp.h"
  18. /*
  19.  * Define PLUGIN_TRACE to have the wrapper functions print
  20.  * messages to stderr whenever they are called.
  21.  */
  22. #ifdef PLUGIN_TRACE
  23. #include <stdio.h>
  24. #define PLUGINDEBUGSTR(msg) fprintf(stderr, "%sn", msg)
  25. #else
  26. #define PLUGINDEBUGSTR(msg)
  27. #endif
  28. /***********************************************************************
  29.  *
  30.  * Globals
  31.  *
  32.  ***********************************************************************/
  33. static NPNetscapeFuncs gNetscapeFuncs; /* Netscape Function table */
  34. /***********************************************************************
  35.  *
  36.  * Wrapper functions : plugin calling Netscape Navigator
  37.  *
  38.  * These functions let the plugin developer just call the APIs
  39.  * as documented and defined in npapi.h, without needing to know
  40.  * about the function table and call macros in npupp.h.
  41.  *
  42.  ***********************************************************************/
  43. void
  44. NPN_Version(int *plugin_major, int *plugin_minor,
  45.     int *netscape_major, int *netscape_minor)
  46. {
  47.     *plugin_major = NP_VERSION_MAJOR;
  48.     *plugin_minor = NP_VERSION_MINOR;
  49.     /* Major version is in high byte */
  50.     *netscape_major = gNetscapeFuncs.version >> 8;
  51.     /* Minor version is in low byte */
  52.     *netscape_minor = gNetscapeFuncs.version & 0xFF;
  53. }
  54. NPError NPN_GetValue(NPP instance, NPNVariable variable, void *r_value)
  55. {
  56.     return CallNPN_GetValueProc(gNetscapeFuncs.getvalue,
  57. instance, variable, r_value);
  58. }
  59. NPError NPN_GetURL(NPP instance, const char *url, const char *window)
  60. {
  61.     return CallNPN_GetURLProc(gNetscapeFuncs.geturl, instance, url,
  62.       window);
  63. }
  64. NPError
  65. NPN_PostURL(NPP instance, const char *url, const char *window,
  66.     uint32 len, const char *buf, NPBool file)
  67. {
  68.     return CallNPN_PostURLProc(gNetscapeFuncs.posturl, instance,
  69.        url, window, len, buf, file);
  70. }
  71. NPError NPN_RequestRead(NPStream * stream, NPByteRange * rangeList)
  72. {
  73.     return CallNPN_RequestReadProc(gNetscapeFuncs.requestread,
  74.    stream, rangeList);
  75. }
  76. NPError
  77. NPN_NewStream(NPP instance, NPMIMEType type, const char *window,
  78.       NPStream ** stream_ptr)
  79. {
  80.     return CallNPN_NewStreamProc(gNetscapeFuncs.newstream, instance,
  81.  type, window, stream_ptr);
  82. }
  83. int32 NPN_Write(NPP instance, NPStream * stream, int32 len, void *buffer)
  84. {
  85.     return CallNPN_WriteProc(gNetscapeFuncs.write, instance,
  86.      stream, len, buffer);
  87. }
  88. NPError NPN_DestroyStream(NPP instance, NPStream * stream, NPError reason)
  89. {
  90.     return CallNPN_DestroyStreamProc(gNetscapeFuncs.destroystream,
  91.      instance, stream, reason);
  92. }
  93. void NPN_Status(NPP instance, const char *message)
  94. {
  95.     CallNPN_StatusProc(gNetscapeFuncs.status, instance, message);
  96. }
  97. const char *NPN_UserAgent(NPP instance)
  98. {
  99.     return CallNPN_UserAgentProc(gNetscapeFuncs.uagent, instance);
  100. }
  101. void *NPN_MemAlloc(uint32 size)
  102. {
  103.     return CallNPN_MemAllocProc(gNetscapeFuncs.memalloc, size);
  104. }
  105. void NPN_MemFree(void *ptr)
  106. {
  107.     CallNPN_MemFreeProc(gNetscapeFuncs.memfree, ptr);
  108. }
  109. uint32 NPN_MemFlush(uint32 size)
  110. {
  111.     return CallNPN_MemFlushProc(gNetscapeFuncs.memflush, size);
  112. }
  113. void NPN_ReloadPlugins(NPBool reloadPages)
  114. {
  115.     CallNPN_ReloadPluginsProc(gNetscapeFuncs.reloadplugins, reloadPages);
  116. }
  117. JRIEnv *NPN_GetJavaEnv()
  118. {
  119.     return CallNPN_GetJavaEnvProc(gNetscapeFuncs.getJavaEnv);
  120. }
  121. jref NPN_GetJavaPeer(NPP instance)
  122. {
  123.     return CallNPN_GetJavaPeerProc(gNetscapeFuncs.getJavaPeer, instance);
  124. }
  125. /***********************************************************************
  126.  *
  127.  * Wrapper functions : Netscape Navigator -> plugin
  128.  *
  129.  * These functions let the plugin developer just create the APIs
  130.  * as documented and defined in npapi.h, without needing to 
  131.  * install those functions in the function table or worry about
  132.  * setting up globals for 68K plugins.
  133.  *
  134.  ***********************************************************************/
  135. NPError
  136. Private_New(NPMIMEType pluginType, NPP instance, uint16 mode,
  137.     int16 argc, char *argn[], char *argv[], NPSavedData * saved)
  138. {
  139.     NPError ret;
  140.     PLUGINDEBUGSTR("New");
  141.     ret = NPP_New(pluginType, instance, mode, argc, argn, argv, saved);
  142.     return ret;
  143. }
  144. NPError Private_Destroy(NPP instance, NPSavedData ** save)
  145. {
  146.     PLUGINDEBUGSTR("Destroy");
  147.     return NPP_Destroy(instance, save);
  148. }
  149. NPError Private_SetWindow(NPP instance, NPWindow * window)
  150. {
  151.     NPError err;
  152.     PLUGINDEBUGSTR("SetWindow");
  153.     err = NPP_SetWindow(instance, window);
  154.     return err;
  155. }
  156. NPError
  157. Private_NewStream(NPP instance, NPMIMEType type, NPStream * stream,
  158.   NPBool seekable, uint16 * stype)
  159. {
  160.     NPError err;
  161.     PLUGINDEBUGSTR("NewStream");
  162.     err = NPP_NewStream(instance, type, stream, seekable, stype);
  163.     return err;
  164. }
  165. int32 Private_WriteReady(NPP instance, NPStream * stream)
  166. {
  167.     unsigned int result;
  168.     PLUGINDEBUGSTR("WriteReady");
  169.     result = NPP_WriteReady(instance, stream);
  170.     return result;
  171. }
  172. int32
  173. Private_Write(NPP instance, NPStream * stream, int32 offset, int32 len,
  174.       void *buffer)
  175. {
  176.     unsigned int result;
  177.     PLUGINDEBUGSTR("Write");
  178.     result = NPP_Write(instance, stream, offset, len, buffer);
  179.     return result;
  180. }
  181. void
  182. Private_StreamAsFile(NPP instance, NPStream * stream, const char *fname)
  183. {
  184.     PLUGINDEBUGSTR("StreamAsFile");
  185.     NPP_StreamAsFile(instance, stream, fname);
  186. }
  187. NPError
  188. Private_DestroyStream(NPP instance, NPStream * stream, NPError reason)
  189. {
  190.     NPError err;
  191.     PLUGINDEBUGSTR("DestroyStream");
  192.     err = NPP_DestroyStream(instance, stream, reason);
  193.     return err;
  194. }
  195. void Private_Print(NPP instance, NPPrint * platformPrint)
  196. {
  197.     PLUGINDEBUGSTR("Print");
  198.     NPP_Print(instance, platformPrint);
  199. }
  200. JRIGlobalRef Private_GetJavaClass(void)
  201. {
  202.     jref clazz = NPP_GetJavaClass();
  203.     if (clazz) {
  204. JRIEnv *env = NPN_GetJavaEnv();
  205. return JRI_NewGlobalRef(env, clazz);
  206.     }
  207.     return NULL;
  208. }
  209. /*********************************************************************** 
  210.  *
  211.  * These functions are located automagically by netscape.
  212.  *
  213.  ***********************************************************************/
  214. /*
  215.  * NP_GetMIMEDescription
  216.  * - Netscape needs to know about this symbol
  217.  * - Netscape uses the return value to identify when an object instance
  218.  *   of this plugin should be created.
  219.  */
  220. char *NP_GetMIMEDescription(void)
  221. {
  222.     return NPP_GetMIMEDescription();
  223. }
  224. /*
  225.  * NP_GetValue [optional]
  226.  * - Netscape needs to know about this symbol.
  227.  * - Interfaces with plugin to get values for predefined variables
  228.  *   that the navigator needs.
  229.  */
  230. NPError NP_GetValue(void *future, NPPVariable variable, void *value)
  231. {
  232.     return NPP_GetValue(future, variable, value);
  233. }
  234. /*
  235.  * NP_Initialize
  236.  * - Netscape needs to know about this symbol.
  237.  * - It calls this function after looking up its symbol before it
  238.  *   is about to create the first ever object of this kind.
  239.  *
  240.  * PARAMETERS
  241.  *    nsTable - The netscape function table. If developers just use these
  242.  *   wrappers, they dont need to worry about all these function
  243.  *   tables.
  244.  * RETURN
  245.  *    pluginFuncs
  246.  * - This functions needs to fill the plugin function table
  247.  *   pluginFuncs and return it. Netscape Navigator plugin
  248.  *   library will use this function table to call the plugin.
  249.  *
  250.  */
  251. NPError
  252. NP_Initialize(NPNetscapeFuncs * nsTable, NPPluginFuncs * pluginFuncs)
  253. {
  254.     NPError err = NPERR_NO_ERROR;
  255.     PLUGINDEBUGSTR("NP_Initialize");
  256.     /* validate input parameters */
  257.     if ((nsTable == NULL) || (pluginFuncs == NULL))
  258. err = NPERR_INVALID_FUNCTABLE_ERROR;
  259.     /*
  260.      * Check the major version passed in Netscape's function table.
  261.      * We won't load if the major version is newer than what we expect.
  262.      * Also check that the function tables passed in are big enough for
  263.      * all the functions we need (they could be bigger, if Netscape added
  264.      * new APIs, but that's OK with us -- we'll just ignore them).
  265.      *
  266.      */
  267.     if (err == NPERR_NO_ERROR) {
  268. if ((nsTable->version >> 8) > NP_VERSION_MAJOR)
  269.     err = NPERR_INCOMPATIBLE_VERSION_ERROR;
  270. if (nsTable->size < sizeof(NPNetscapeFuncs))
  271.     err = NPERR_INVALID_FUNCTABLE_ERROR;
  272. if (pluginFuncs->size < sizeof(NPPluginFuncs))
  273.     err = NPERR_INVALID_FUNCTABLE_ERROR;
  274.     }
  275.     if (err == NPERR_NO_ERROR) {
  276. /*
  277.  * Copy all the fields of Netscape function table into our
  278.  * copy so we can call back into Netscape later.  Note that
  279.  * we need to copy the fields one by one, rather than assigning
  280.  * the whole structure, because the Netscape function table
  281.  * could actually be bigger than what we expect.
  282.  */
  283. gNetscapeFuncs.version = nsTable->version;
  284. gNetscapeFuncs.size = nsTable->size;
  285. gNetscapeFuncs.posturl = nsTable->posturl;
  286. gNetscapeFuncs.geturl = nsTable->geturl;
  287. gNetscapeFuncs.requestread = nsTable->requestread;
  288. gNetscapeFuncs.newstream = nsTable->newstream;
  289. gNetscapeFuncs.write = nsTable->write;
  290. gNetscapeFuncs.destroystream = nsTable->destroystream;
  291. gNetscapeFuncs.status = nsTable->status;
  292. gNetscapeFuncs.uagent = nsTable->uagent;
  293. gNetscapeFuncs.memalloc = nsTable->memalloc;
  294. gNetscapeFuncs.memfree = nsTable->memfree;
  295. gNetscapeFuncs.memflush = nsTable->memflush;
  296. gNetscapeFuncs.reloadplugins = nsTable->reloadplugins;
  297. gNetscapeFuncs.getJavaEnv = nsTable->getJavaEnv;
  298. gNetscapeFuncs.getJavaPeer = nsTable->getJavaPeer;
  299. gNetscapeFuncs.getvalue = nsTable->getvalue;
  300. /*
  301.  * Set up the plugin function table that Netscape will use to
  302.  * call us.  Netscape needs to know about our version and size
  303.  * and have a UniversalProcPointer for every function we
  304.  * implement.
  305.  */
  306. pluginFuncs->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR;
  307. pluginFuncs->size = sizeof(NPPluginFuncs);
  308. pluginFuncs->newp = NewNPP_NewProc(Private_New);
  309. pluginFuncs->destroy = NewNPP_DestroyProc(Private_Destroy);
  310. pluginFuncs->setwindow = NewNPP_SetWindowProc(Private_SetWindow);
  311. pluginFuncs->newstream = NewNPP_NewStreamProc(Private_NewStream);
  312. pluginFuncs->destroystream =
  313.     NewNPP_DestroyStreamProc(Private_DestroyStream);
  314. pluginFuncs->asfile =
  315.     NewNPP_StreamAsFileProc(Private_StreamAsFile);
  316. pluginFuncs->writeready =
  317.     NewNPP_WriteReadyProc(Private_WriteReady);
  318. pluginFuncs->write = NewNPP_WriteProc(Private_Write);
  319. pluginFuncs->print = NewNPP_PrintProc(Private_Print);
  320. pluginFuncs->event = NULL;
  321. pluginFuncs->javaClass = Private_GetJavaClass();
  322. err = NPP_Initialize();
  323.     }
  324.     return err;
  325. }
  326. /*
  327.  * NP_Shutdown [optional]
  328.  * - Netscape needs to know about this symbol.
  329.  * - It calls this function after looking up its symbol after
  330.  *   the last object of this kind has been destroyed.
  331.  *
  332.  */
  333. NPError NP_Shutdown(void)
  334. {
  335.     PLUGINDEBUGSTR("NP_Shutdown");
  336.     NPP_Shutdown();
  337.     return NPERR_NO_ERROR;
  338. }