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