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         /* prevent before multiple instances */
 113         system ("killall arenalive-linux -s9");
 114
 115         return NPERR_NO_ERROR;
 116 }
 117
 118
 119 char *NP_GetMIMEDescription ()
 120 {
 121         Log ("get mime");
 122         return "x-application/glugin:gln:Glugin;";
 123 }
 124
 125 NPError NP_GetValue (void *instance, NPPVariable variable, void *value)
 126 {
 127         Log ("get value");
 128
 129         switch (variable) {
 130                 case NPPVpluginNameString:
 131                         (*(char **) value) = "Arena Live";
 132                         break;
 133                 case NPPVpluginDescriptionString:
 134                         (*(char **) value) = "Arena Live plugin";
 135                         break;
 136                 default:
 137                         return NPERR_INVALID_PARAM;
 138         }
 139
 140         return NPERR_NO_ERROR;
 141 }
 142
 143 NPError NPP_New (
 144         NPMIMEType mime,
 145         NPP instance,
 146         uint16 mode,
 147         int16 argc, char *argn[], char *argv[],
 148         NPSavedData *saved)
 149 {
 150         int i;
 151         pluginData *pd;
 152
 153         Log ("new p");
 154
 155         gNetscapeFuncs.setvalue (instance, NPPVpluginTransparentBool, false);
 156
 157         instance->pdata = gNetscapeFuncs.memalloc (sizeof (pluginData));
 158
 159         Log ("allocated");
 160
 161         pd = pdof (instance);
 162
 163         pd->exit_request = 0;
 164         pd->exit_ack = 0;
 165         pd->has_window = 0;
 166
 167         pd->conparam = 0;
 168         pd->action = -1;
 169
 170         for (i = 0; i < argc; ++ i) {
 171                 if (!strcmp (argn[i], "conparam")) {
 172                         Log ("html tag parameter - conparam");
 173
 174                         pd->conparam = strdup (argv[i]);
 175                 } else
 176                 if (!strcmp (argn[i], "action")) {
 177                         Log ("html tag parameter - action");
 178
 179                         pd->action = atoi (argv[i]);
 180                 }
 181
 182         }
 183
 184         return NPERR_NO_ERROR;
 185 }
 186
 187 void set_nonblock (int fd)
 188 {
 189         long flags = fcntl (fd, F_GETFL, 0);
 190
 191         flags |= (O_NONBLOCK | O_NDELAY);
 192
 193         fcntl (fd, F_SETFL, flags);
 194 }
 195
 196 NPError NPP_SetWindow (NPP instance, NPWindow *w)
 197 {
 198         pluginData *pd = pdof (instance);
 199         pid_t child;
 200         int pw[2], pr[2];
 201
 202         if (!w) {
 203                 Log ("setwindow: destroyed");
 204                 return NPERR_NO_ERROR;
 205         }
 206
 207         if (!pd->has_window) {
 208                 pd->has_window = 1;
 209
 210                 pipe (pw);
 211                 pipe (pr);
 212
 213                 set_nonblock (pr[0]);
 214                 set_nonblock (pr[1]);
 215                 set_nonblock (pw[0]);
 216                 set_nonblock (pw[1]);
 217
 218                 child = fork ();
 219
 220                 if (child == -1)
 221                         return NPERR_MODULE_LOAD_FAILED_ERROR;
 222
 223                 if (!child) {
 224                         Log ("in new process!");
 225
 226                         close (pw[1]);
 227                         close (pr[0]);
 228
 229                         pd->pw = fdopen (pr[1], "w");
 230                         pd->pr = fdopen (pw[0], "r");
 231
 232                         /* TODO check if setsid is needed here */
 233
 234                         plugin_process_handler (pd, pd->win = (Window) (w->window), ((NPSetWindowCallbackStruct *) (w->ws_info))->visual);
 235
 236                         _exit (0);
 237                 } else {
 238                         pd->child = child;
 239
 240                         close (pw[0]);
 241                         close (pr[1]);
 242
 243                         pd->pw = fdopen (pw[1], "w");
 244                         pd->pr = fdopen (pr[0], "r");
 245                 }
 246         }
 247
 248         // we don't really care about window resize events, as long as
 249         // it can catch them by native methods
 250
 251         return NPERR_NO_ERROR;
 252 }
 253
 254
 255 int16 NPP_HandleEvent (NPP instance, void *event)
 256 {
 257         Log ("event");
 258
 259         return true;
 260 }
 261
 262 NPError NPP_Destroy (NPP instance, NPSavedData **saved)
 263 {
 264         pluginData *pd = pdof (instance);
 265
 266         Log ("killing child...");
 267
 268         kill (pd->child, SIGUSR1);
 269
 270         fclose (pd->pw);
 271         fclose (pd->pr);
 272
 273         usleep (10000);
 274
 275         //TODO
 276         //wait until the child really terminates. Mutexes?
 277
 278         gNetscapeFuncs.memfree (instance->pdata);
 279         Log ("deleted ok");
 280
 281         return NPERR_NO_ERROR;
 282 }
 283
 284 void NPP_Print (NPP instance, NPPrint *printInfo)
 285 {
 286         Log ("attempt to print");
 287 }
 288
 289 NPError NPP_NewStream (NPP instance, NPMIMEType type, NPStream *stream, NPBool seekable, uint16* stype)
 290 {
 291         Log ("new stream");
 292
 293         host_newstream (pdof (instance), stream);
 294
 295         return NPERR_NO_ERROR;
 296 }
 297
 298 NPError NPP_DestroyStream (NPP instance, NPStream *stream, NPReason reason)
 299 {
 300         Log ("destroy stream");
 301
 302         host_destroystream (pdof (instance), stream);
 303
 304         return NPERR_NO_ERROR;
 305 }
 306
 307 int32 NPP_Write (NPP instance, NPStream *stream, int32 offset, int32 len, void *buf)
 308 {
 309         Log ("write %d",len);
 310
 311         host_write (pdof (instance), stream, offset, len, buf);
 312
 313         return len;
 314 }
 315
 316 void NPP_StreamAsFile (NPP instance, NPStream* stream, const char* fname)
 317 {
 318         Log ("as file:");
 319         Log (fname);
 320 }
 321
 322 int32 NPP_WriteReady (NPP instance, NPStream *stream)
 323 {
 324         Log("write ready");
 325
 326         return 1024; //ooh replace.
 327 }
 328
 329 void resize (Display *dpy, Window win)
 330 {
 331         XWindowAttributes wa;
 332
 333         XGetWindowAttributes (dpy, win, &wa);
 334
 335         glViewport (0,0,wa.width, wa.height);
 336 }
 337
 338
 339 static pluginData *g_pd;
 340
 341 void sig_usr1 (int i)
 342 {
 343         g_pd->exit_request = 1;
 344 }
 345
 346 void swapbuffers (pluginData *pd)
 347 {
 348         glXSwapBuffers (pd->dpy, pd->win);
 349 }
 350
 351 void plugin_process_handler (pluginData *pd, Window win, Visual *vis)
 352 {
 353         g_pd = pd;
 354
 355         pd->win = win;
 356
 357         signal (SIGUSR1, sig_usr1);
 358
 359         /* call action function */
 360         plugin_action (pd);
 361
 362         Log ("plugin killed, cleaning up.");
 363
 364         fclose (pd->pw);
 365         fclose (pd->pr);
 366
 367         //glXMakeCurrent(dpy, None, 0);
 368         //glXDestroyContext(dpy,ctx);
 369
 370         if (pd->conparam)
 371                 free (pd->conparam);
 372 }
 373
 374 void writedata (FILE *f, void *x, unsigned len)
 375 {
 376         fwrite (x, len, sizeof (char), f);
 377 }
 378
 379 void host_newstream (pluginData *pd, NPStream *s)
 380 {
 381         writedata (pd->pw, (void *) gln_new_stream, sizeof (int));
 382         writedata (pd->pw, (void *) &s, sizeof (NPStream));
 383
 384         fflush (pd->pw);
 385 }
 386
 387 void host_destroystream (pluginData*pd, NPStream*s)
 388 {
 389         writedata (pd->pw, (void *) gln_destroy_stream, sizeof (int));
 390         writedata (pd->pw, (void *) s, sizeof (NPStream));
 391
 392         fflush (pd->pw);
 393 }
 394
 395 void host_write (pluginData *pd, NPStream *s, int32 off, int32 siz, void *data)
 396 {
 397         writedata (pd->pw, (void *) gln_stream_data, sizeof (int));
 398         writedata (pd->pw, (void *) s, sizeof (NPStream));
 399         writedata (pd->pw, (void *) &off, sizeof (off));
 400         writedata (pd->pw, (void *) &siz, sizeof (off));
 401
 402         fwrite (data, siz, sizeof (char), pd->pw);
 403
 404         fflush (pd->pw);
 405 }
 406
 407 void host_read_guest_requests (pluginData *pd)
 408 {
 409         Log ("Reading guest requests");
 410 }