/*****************************************************************************
  FILE: nptango.c, TomaszMajor-14May98, mc-v0.00-20Feb97
  PURPOSE: Tango plugin for Netscape
*****************************************************************************/


#include <stdio.h>
#include <string.h>
#include "npapi.h"

/*Define IMPLEMENT_* before including *.h to state that we're
  implementing the native methods of this plug-in here,
  and consequently need to access it's protected and private members.*/
#include "webwisdom_tango_structures_LocalBase.h"


#define CL "nptango.c: " 
#define CL2 "TANGO plugin: " 


/*We'll keep a global execution environment around to make our life simpler.*/
JRIEnv* JRIENV_env;


/*Tango variables*/
char *serverHost;
char *serverPort;
char *localPort;

char *rootDir;


#ifdef XP_UNIX

#define PLUGIN_MIME "application/x-collaboratory"
#define PLUGIN_SUFFIXES "*"
#define PLUGIN_NAME "Tango v.1.0"
#define PLUGIN_TITLE "TANGO Interactive"
#define PLUGIN_DESCRIPTION "<center><b>Collaboratory</b> system for the Web created at <a href=\"http://www.npac.syr.edu\">NPAC</a>, Syracuse University.<br>Tango is used in education & distance learning, command & control,<br>health care, computer steering, and entertainment.<br><a href=\"http://trurl.npac.syr.edu/tango\"><b>Start TANGO</b></a></center>"


char* NPP_GetMIMEDescription(void)
{
  return(PLUGIN_MIME":"PLUGIN_SUFFIXES":"PLUGIN_NAME);
}/* NPP_GetMIMEDescription ************************************************/


NPError NPP_GetValue(void *future,NPPVariable variable,void *value)
{
  NPError err=NPERR_NO_ERROR;

  if(variable==NPPVpluginNameString)
    *((char **)value)=PLUGIN_TITLE;
  else if(variable==NPPVpluginDescriptionString)
    *((char **)value)=PLUGIN_DESCRIPTION;
  else
    err=NPERR_GENERIC_ERROR;
  
  return err;
}/* NPP_GetValue **********************************************************/
#endif /*XP_UNIX*/


/****************************************************************************
  NPP_Initialize is called when your DLL is being loaded to do any
  DLL-specific initialization.
****************************************************************************/
NPError NPP_Initialize(void)
{
  return NPERR_NO_ERROR;
}/* NPP_Initialize *********************************************************/


/***************************************************************************
  NPP_GetJavaClass is called during initialization to ask your plugin
  what its associated Java class is. If you don't have one, just return
  NULL. Otherwise, use the javah-generated "use_" function to both
  initialize your class and return it. If you can't find your class, an
  error will be signalled by "use_" and will cause the Navigator to
  complain to the user.
***************************************************************************/
jref NPP_GetJavaClass()
{
  struct java_lang_Class *lb_class;
  JRIENV_env=NPN_GetJavaEnv();
  if(JRIENV_env==NULL)
  {
    fprintf(stderr,CL"Java disabled!\n");
    return NULL;
  }
  lb_class=use_webwisdom_tango_structures_LocalBase(JRIENV_env);
  if(lb_class==NULL)
  {
    fprintf(stderr,CL"webwisdom.tango.structures.LocalBase.class not installed!\n");
    return NULL;
  }
  return lb_class;
}/* NPP_GetJavaClass ******************************************************/


/***************************************************************************
  NPP_Shutdown is called when your DLL is being unloaded to do any
  DLL-specific shut-down. You should be a good citizen and declare that
  you're not using your java class any more. This allows java to unload
  it, freeing up memory.
***************************************************************************/
void NPP_Shutdown(void)
{
  if(JRIENV_env)
    unuse_webwisdom_tango_structures_LocalBase(JRIENV_env);
}/* NPP_Shutdown **********************************************************/


/***************************************************************************
  NPP_New is called when your plugin is instantiated (i.e. when an EMBED
  tag appears on a page).
***************************************************************************/
NPError NPP_New(NPMIMEType pluginType,
		NPP instance,
		uint16 mode,
		int16 argc,
		char* argn[],
		char* argv[],
		NPSavedData* saved)
{
  NPError result=NPERR_NO_ERROR;
  int i;

  serverHost=NULL;
  serverPort=NULL;
  localPort=NULL;

  for(i=0;i<argc;i++)
  {
    if(argn[i]==NULL)
    {
      /*fprintf(stderr,CL"null parameter name (%d) passed!\n",i); */
      continue;
    }

    /*fprintf(stderr,CL"param \'%s\'=\"%s\"\n",argn[i],argv[i]); */
    if(strcasecmp(argn[i],"serverHost")==0)
    {
      serverHost=NPN_MemAlloc(strlen(argv[i])+1);
      if(serverHost==NULL)
	return NPERR_OUT_OF_MEMORY_ERROR;
      strcpy(serverHost,argv[i]);
    }
    if(strcasecmp(argn[i],"serverPort")==0)
    {
      serverPort=NPN_MemAlloc(strlen(argv[i])+1);
      if(serverPort==NULL)
	return NPERR_OUT_OF_MEMORY_ERROR;
      strcpy(serverPort,argv[i]);
    }
    if(strcasecmp(argn[i],"localPort")==0)
    {
      localPort=NPN_MemAlloc(strlen(argv[i])+1);
      if(localPort==NULL)
	return NPERR_OUT_OF_MEMORY_ERROR;
      strcpy(localPort,argv[i]);
    }
  }
  
  /*fprintf(stderr,CL"server=%s:%s localPort=%s\n",serverHost,serverPort,localPort); */
  
  rootDir=getenv("TANGO_APP_ROOT"); 
  if(rootDir==NULL)
  {
    fprintf(stderr,CL"cannot getenv(\'TANGO_APP_ROOT\')!\n"); 
    return NPERR_FILE_NOT_FOUND;
  }

  return result;
}/* NPP_New ***************************************************************/


/***************************************************************************
  If desired, call NP_MemAlloc to create a NPSavedDate structure
  containing any state information that you want restored
  if this plugin instance is later recreated.
***************************************************************************/
NPError NPP_Destroy(NPP instance,NPSavedData** save)
{
  if(instance==NULL)
    return NPERR_INVALID_INSTANCE_ERROR;

  if((serverHost)!=NULL)
  {
    NPN_MemFree(serverHost);
    serverHost=NULL;
  }
  if((serverPort)!=NULL)
  {
    NPN_MemFree(serverPort);
    serverPort=NULL;
  }
  if((localPort)!=NULL)
  {
    NPN_MemFree(localPort);
    localPort=NULL;
  }

  return NPERR_NO_ERROR;
}/* NPP_Destroy ***********************************************************/


NPError NPP_SetWindow(NPP instance,NPWindow* window)
{
  if(instance==NULL)
    return NPERR_INVALID_INSTANCE_ERROR;
  return NPERR_NO_ERROR;
}/* NPP_SetWindow *********************************************************/


NPError NPP_NewStream(NPP instance,
		      NPMIMEType type,
		      NPStream *stream, 
		      NPBool seekable,
		      uint16 *stype)
{
  if(instance==NULL)
    return NPERR_INVALID_INSTANCE_ERROR;
  
  return NPERR_NO_ERROR;
}/* NPP_NewStream *********************************************************/


/*PLUGIN DEVELOPERS:
  These next 2 functions are directly relevant in a plug-in which
  handles the data in a streaming manner. If you want zero bytes
  because no buffer space is YET available, return 0. As long as
  the stream has not been written to the plugin, Navigator will
  continue trying to send bytes.  If the plugin doesn't want them,
  just return some large number from NPP_WriteReady(), and
  ignore them in NPP_Write().  For a NP_ASFILE stream, they are
  still called but can safely be ignored using this strategy.*/


int32 NPP_WriteReady(NPP instance,NPStream *stream)
{
  return 0;
}/* NPP_WriteReady ********************************************************/


int32 NPP_Write(NPP instance,
		NPStream *stream,
		int32 offset,
		int32 len,
		void *buffer)
{	
  return len; /* The number of bytes accepted */
}/* NPP_Write *************************************************************/
 

NPError NPP_DestroyStream(NPP instance,
			  NPStream *stream,
			  NPError reason)
{
  if(instance==NULL)
    return NPERR_INVALID_INSTANCE_ERROR;
  return NPERR_NO_ERROR;
}/* NPP_DestroyStream *****************************************************/


void NPP_StreamAsFile(NPP instance,
		      NPStream *stream,
		      const char* fname)
{
  return;
}/* NPP_StreamAsFile ******************************************************/

 
void NPP_Print(NPP instance,
	       NPPrint* printInfo)
{
  return;
}/* NPP_Print *************************************************************/


/***************************************************************************
  NPP_URLNotify:
  Notifies the instance of the completion of a URL request. 
 
  NPP_URLNotify is called when Netscape completes a NPN_GetURLNotify or
  NPN_PostURLNotify request, to inform the plug-in that the request,
  identified by url, has completed for the reason specified by reason. The most
  common reason code is NPRES_DONE, indicating simply that the request
  completed normally. Other possible reason codes are NPRES_USER_BREAK,
  indicating that the request was halted due to a user action (for example,
  clicking the "Stop" button), and NPRES_NETWORK_ERR, indicating that the
  request could not be completed (for example, because the URL could not be
  found). The complete list of reason codes is found in npapi.h. 
 
  The parameter notifyData is the same plug-in-private value passed as an
  argument to the corresponding NPN_GetURLNotify or NPN_PostURLNotify
  call, and can be used by your plug-in to uniquely identify the request. 
***************************************************************************/
void NPP_URLNotify(NPP instance,
		   const char *url,
		   NPReason reason,
		   void* notifyData)
{
  return;
}/* NPP_URLNotify *********************************************************/


/* Tango native methods starts here: */


JRI_PUBLIC_API(jint)
native_webwisdom_tango_structures_LocalBase_runApplication(JRIEnv* env, struct webwisdom_tango_structures_LocalBase* self, struct java_lang_String *a, jint AID, jint SID, jint AT, jint port)
{
  const char *appName=JRI_GetStringUTFChars(env,a);
  char path[FILENAME_MAX];
  char AIDstr[16],SIDstr[16],ATstr[16],PORTstr[16]; 
 

  if(appName==NULL)
  {
    fprintf(stderr,CL"error: appName=null!\n"); 
    return -2;
  }

  sprintf(path,"%s/%s",rootDir,appName); 
  sprintf(AIDstr,"%d",AID); 
  sprintf(SIDstr,"%d",SID); 
  sprintf(ATstr,"%d",AT); 
  sprintf(PORTstr,"%d",port); 


  {
    int childpid=fork(); 
    if(childpid==0)
    { 
      int i;
      for(i=3;i<256;i++)
	close(i);

      /*fprintf(stderr,CL"running \"%s %s %s %s %s\"\n",
	path,AIDstr,SIDstr,ATstr,PORTstr);*/
      execl(path,path,AIDstr,SIDstr,ATstr,PORTstr,(char *)0);   
      fprintf(stderr,CL"cannot exec command \'%s\'!\n",path);
      exit(0);
    }
    else if(childpid==-1)
    {
      fprintf(stderr,CL"cannot fork!\n"); 
      return -1;
    }
    else
    {
      return 0;
    }
  }
}/* runApplication ********************************************************/


JRI_PUBLIC_API(struct java_lang_String *)   
native_webwisdom_tango_structures_LocalBase_getServerHost(JRIEnv* env,struct webwisdom_tango_structures_LocalBase* self)
{
  struct java_lang_String *jHost;   
  if(serverHost==NULL)
  {
    char host[2];
    host[0]='*';
    host[1]='\0';
    jHost=(struct java_lang_String *)JRI_NewStringUTF(env,host,(jsize)strlen(host));
  }
  else
  {
    jHost=(struct java_lang_String *)JRI_NewStringUTF(env,serverHost,(jsize)strlen(serverHost)); 
  }
  return jHost;
}/* getServerHost *********************************************************/


JRI_PUBLIC_API(jint)  
native_webwisdom_tango_structures_LocalBase_getServerPort(JRIEnv* env,webwisdom_tango_structures_LocalBase* self)
{
  if(serverPort==NULL)
    return -1;
  return atoi(serverPort);
}/* getServerPort *********************************************************/


JRI_PUBLIC_API(jint)   
native_webwisdom_tango_structures_LocalBase_getLocalPort(JRIEnv* env,webwisdom_tango_structures_LocalBase* self)
{
  if(localPort==NULL)
    return -1;
  return atoi(localPort); 
}/* getLocalPort **********************************************************/