ns-unix.cpp

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