ns-unix.c

   1 /*
   2  *  (C) Copyright 2009 ZeXx86 (zexx86@gmail.com)
   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 2 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 have 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  *   Based on GLugin http://exa.czweb.org/repos/glugin.tar.bz2
  19  *   Big thanks for "exa"
  20  */
  21
  22
  23 #include <stdio.h>
  24 #include <ctype.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <sys/types.h>
  29 #include <signal.h>
  30
  31 #include <GL/glx.h>
  32
  33 #include "glugin.h"
  34
  35 static NPNetscapeFuncs gNetscapeFuncs;  /* Netscape Function table */
  36
  37 /* prototypes */
  38 void plugin_process_handler (pluginData *, Window, Visual *);
  39
  40
  41 NPError NP_Initialize (NPNetscapeFuncs *nsTable, NPPluginFuncs *pluginFuncs)
  42 {
  43         Log ("init");
  44
  45         /* this is respectfully taken from mplayerplug-in, as it was observed
  46          * and proved to be extremely useful. */
  47         if ((nsTable == NULL) || (pluginFuncs == NULL))
  48                 return NPERR_INVALID_FUNCTABLE_ERROR;
  49
  50         Log ("table ok");
  51
  52         if ((nsTable->version >> 8) > NP_VERSION_MAJOR)
  53                 return NPERR_INCOMPATIBLE_VERSION_ERROR;
  54
  55         Log ("table version ok");
  56
  57         /*check for table size removed, probable alignment or such problems.
  58          *
  59
  60         if (nsTable->size < sizeof(NPNetscapeFuncs))
  61                 return NPERR_INVALID_FUNCTABLE_ERROR;
  62         Log("table size ok");
  63
  64          */
  65
  66         if (pluginFuncs->size < sizeof (NPPluginFuncs))
  67                 return NPERR_INVALID_FUNCTABLE_ERROR;
  68
  69         Log ("ok pluginfuncs size check");
  70
  71         Log ("ok initing");
  72
  73         gNetscapeFuncs.version = nsTable->version;
  74         gNetscapeFuncs.size = nsTable->size;
  75         gNetscapeFuncs.posturl = nsTable->posturl;
  76         gNetscapeFuncs.geturl = nsTable->geturl;
  77         gNetscapeFuncs.requestread = nsTable->requestread;
  78         gNetscapeFuncs.newstream = nsTable->newstream;
  79         gNetscapeFuncs.write = nsTable->write;
  80         gNetscapeFuncs.destroystream = nsTable->destroystream;
  81         gNetscapeFuncs.status = nsTable->status;
  82         gNetscapeFuncs.uagent = nsTable->uagent;
  83         gNetscapeFuncs.memalloc = nsTable->memalloc;
  84         gNetscapeFuncs.memfree = nsTable->memfree;
  85         gNetscapeFuncs.memflush = nsTable->memflush;
  86         gNetscapeFuncs.reloadplugins = nsTable->reloadplugins;
  87         gNetscapeFuncs.getJavaEnv = nsTable->getJavaEnv;
  88         gNetscapeFuncs.getJavaPeer = nsTable->getJavaPeer;
  89         gNetscapeFuncs.getvalue = nsTable->getvalue;
  90         gNetscapeFuncs.setvalue = nsTable->setvalue;
  91
  92         pluginFuncs->version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
  93         pluginFuncs->size = sizeof (NPPluginFuncs);
  94         pluginFuncs->newp = NPP_New;
  95         pluginFuncs->destroy = NPP_Destroy;
  96         pluginFuncs->event = NPP_HandleEvent;
  97         pluginFuncs->setwindow = NPP_SetWindow;
  98         pluginFuncs->print = NPP_Print;
  99         pluginFuncs->newstream = NPP_NewStream;
 100         pluginFuncs->destroystream = NPP_DestroyStream;
 101         pluginFuncs->asfile = NPP_StreamAsFile;
 102         pluginFuncs->writeready = NPP_WriteReady;
 103         pluginFuncs->write = NPP_Write;
 104
 105         return NPERR_NO_ERROR;
 106 }
 107
 108 NPError NP_Shutdown ()
 109 {
 110         Log ("shutdown");
 111
 112         return NPERR_NO_ERROR;
 113 }
 114
 115
 116 char *NP_GetMIMEDescription ()
 117 {
 118         Log ("get mime");
 119         return "x-application/glugin:gln:Glugin;";
 120 }
 121
 122 NPError NP_GetValue (void *instance, NPPVariable variable, void *value)
 123 {
 124         Log ("get value");
 125
 126         switch (variable) {
 127                 case NPPVpluginNameString:
 128                         (*(char **) value) = "Arena Live";
 129                         break;
 130                 case NPPVpluginDescriptionString:
 131                         (*(char **) value) = "Arena Live plugin";
 132                         break;
 133                 default:
 134                         return NPERR_INVALID_PARAM;
 135         }
 136
 137         return NPERR_NO_ERROR;
 138 }
 139
 140 NPError NPP_New (
 141         NPMIMEType mime,
 142         NPP instance,
 143         uint16 mode,
 144         int16 argc, char *argn[], char *argv[],
 145         NPSavedData *saved)
 146 {
 147         int i;
 148         pluginData *pd;
 149
 150         Log ("new p");
 151
 152         gNetscapeFuncs.setvalue (instance, NPPVpluginTransparentBool, false);
 153
 154         instance->pdata = gNetscapeFuncs.memalloc (sizeof (pluginData));
 155
 156         Log ("allocated");
 157
 158         pd = pdof (instance);
 159
 160         pd->exit_request = 0;
 161         pd->exit_ack = 0;
 162         pd->has_window = 0;
 163
 164         pd->conparam = 0;
 165         pd->action = -1;
 166
 167         for (i = 0; i < argc; ++ i) {
 168                 if (!strcmp (argn[i], "conparam")) {
 169                         Log ("html tag parameter - conparam");
 170
 171                         pd->conparam = strdup (argv[i]);
 172                 } else
 173                 if (!strcmp (argn[i], "action")) {
 174                         Log ("html tag parameter - action");
 175
 176                         pd->action = atoi (argv[i]);
 177                 }
 178
 179         }
 180
 181         return NPERR_NO_ERROR;
 182 }
 183
 184 void set_nonblock (int fd)
 185 {
 186         long flags = fcntl (fd, F_GETFL, 0);
 187
 188         flags |= (O_NONBLOCK | O_NDELAY);
 189
 190         fcntl (fd, F_SETFL, flags);
 191 }
 192
 193 NPError NPP_SetWindow (NPP instance, NPWindow *w)
 194 {
 195         pluginData *pd = pdof (instance);
 196         pid_t child;
 197         int pw[2], pr[2];
 198
 199         if (!w) {
 200                 Log ("setwindow: destroyed");
 201                 return NPERR_NO_ERROR;
 202         }
 203
 204         if (!pd->has_window) {
 205                 pd->has_window = 1;
 206
 207                 pipe (pw);
 208                 pipe (pr);
 209
 210                 set_nonblock (pr[0]);
 211                 set_nonblock (pr[1]);
 212                 set_nonblock (pw[0]);
 213                 set_nonblock (pw[1]);
 214
 215                 child = fork ();
 216
 217                 if (child == -1)
 218                         return NPERR_MODULE_LOAD_FAILED_ERROR;
 219
 220                 if (!child) {
 221                         Log ("in new process!");
 222
 223                         close (pw[1]);
 224                         close (pr[0]);
 225
 226                         pd->pw = fdopen (pr[1], "w");
 227                         pd->pr = fdopen (pw[0], "r");
 228
 229                         /* TODO check if setsid is needed here */
 230
 231                         plugin_process_handler (pd, pd->win = (Window) (w->window), ((NPSetWindowCallbackStruct *) (w->ws_info))->visual);
 232
 233                         _exit (0);
 234                 } else {
 235                         pd->child = child;
 236
 237                         close (pw[0]);
 238                         close (pr[1]);
 239
 240                         pd->pw = fdopen (pw[1], "w");
 241                         pd->pr = fdopen (pr[0], "r");
 242                 }
 243         }
 244
 245         // we don't really care about window resize events, as long as
 246         // it can catch them by native methods
 247
 248         return NPERR_NO_ERROR;
 249 }
 250
 251
 252 int16 NPP_HandleEvent (NPP instance, void *event)
 253 {
 254         Log ("event");
 255
 256         return true;
 257 }
 258
 259 NPError NPP_Destroy (NPP instance, NPSavedData **saved)
 260 {
 261         pluginData *pd = pdof (instance);
 262
 263         Log ("killing child...");
 264
 265         kill (pd->child, SIGUSR1);
 266
 267         fclose (pd->pw);
 268         fclose (pd->pr);
 269
 270         usleep (10000);
 271
 272         //TODO
 273         //wait until the child really terminates. Mutexes?
 274
 275         gNetscapeFuncs.memfree (instance->pdata);
 276         Log ("deleted ok");
 277
 278         return NPERR_NO_ERROR;
 279 }
 280
 281 void NPP_Print (NPP instance, NPPrint *printInfo)
 282 {
 283         Log ("attempt to print");
 284 }
 285
 286 NPError NPP_NewStream (NPP instance, NPMIMEType type, NPStream *stream, NPBool seekable, uint16* stype)
 287 {
 288         Log ("new stream");
 289
 290         host_newstream (pdof (instance), stream);
 291
 292         return NPERR_NO_ERROR;
 293 }
 294
 295 NPError NPP_DestroyStream (NPP instance, NPStream *stream, NPReason reason)
 296 {
 297         Log ("destroy stream");
 298
 299         host_destroystream (pdof (instance), stream);
 300
 301         return NPERR_NO_ERROR;
 302 }
 303
 304 int32 NPP_Write (NPP instance, NPStream *stream, int32 offset, int32 len, void *buf)
 305 {
 306         Log ("write %d",len);
 307
 308         host_write (pdof (instance), stream, offset, len, buf);
 309
 310         return len;
 311 }
 312
 313 void NPP_StreamAsFile (NPP instance, NPStream* stream, const char* fname)
 314 {
 315         Log ("as file:");
 316         Log (fname);
 317 }
 318
 319 int32 NPP_WriteReady (NPP instance, NPStream *stream)
 320 {
 321         Log("write ready");
 322
 323         return 1024; //ooh replace.
 324 }
 325
 326 void resize (Display *dpy, Window win)
 327 {
 328         XWindowAttributes wa;
 329
 330         XGetWindowAttributes (dpy, win, &wa);
 331
 332         glViewport (0,0,wa.width, wa.height);
 333 }
 334
 335
 336 static pluginData *g_pd;
 337
 338 void sig_usr1 (int i)
 339 {
 340         g_pd->exit_request = 1;
 341 }
 342
 343 void swapbuffers (pluginData *pd)
 344 {
 345         glXSwapBuffers (pd->dpy, pd->win);
 346 }
 347
 348 void plugin_process_handler (pluginData *pd, Window win, Visual *vis)
 349 {
 350         g_pd = pd;
 351
 352         pd->win = win;
 353
 354         signal (SIGUSR1, sig_usr1);
 355
 356         /* call action function */
 357         plugin_action (pd);
 358
 359         Log ("plugin killed, cleaning up.");
 360
 361         fclose (pd->pw);
 362         fclose (pd->pr);
 363
 364         //glXMakeCurrent(dpy, None, 0);
 365         //glXDestroyContext(dpy,ctx);
 366
 367         if (pd->conparam)
 368                 free (pd->conparam);
 369 }
 370
 371 void writedata (FILE *f, void *x, unsigned len)
 372 {
 373         fwrite (x, len, sizeof (char), f);
 374 }
 375
 376 void host_newstream (pluginData *pd, NPStream *s)
 377 {
 378         writedata (pd->pw, (void *) gln_new_stream, sizeof (int));
 379         writedata (pd->pw, (void *) &s, sizeof (NPStream));
 380
 381         fflush (pd->pw);
 382 }
 383
 384 void host_destroystream (pluginData*pd, NPStream*s)
 385 {
 386         writedata (pd->pw, (void *) gln_destroy_stream, sizeof (int));
 387         writedata (pd->pw, (void *) s, sizeof (NPStream));
 388
 389         fflush (pd->pw);
 390 }
 391
 392 void host_write (pluginData *pd, NPStream *s, int32 off, int32 siz, void *data)
 393 {
 394         writedata (pd->pw, (void *) gln_stream_data, sizeof (int));
 395         writedata (pd->pw, (void *) s, sizeof (NPStream));
 396         writedata (pd->pw, (void *) &off, sizeof (off));
 397         writedata (pd->pw, (void *) &siz, sizeof (off));
 398
 399         fwrite (data, siz, sizeof (char), pd->pw);
 400
 401         fflush (pd->pw);
 402 }
 403
 404 void host_read_guest_requests (pluginData *pd)
 405 {
 406         Log ("Reading guest requests");
 407 }