JD_IMETHODIMP
JavaPluginFactory5::StartupJVM(JVMInitArgs *initargs) {
trace("JavaPluginFactory5:StartupJVM\n");
JDresult ret = JD_OK;
if (is_java_vm_started) {
plugin_error("StartupJVM is being called twice!\n");
return JD_OK;
}
EnterMonitor("StartupJVM");
/* Make sure someone did not start it up while we were
waiting for the monitor */
if (!is_java_vm_started) {
ret = javaVM->StartJavaVM(initargs->classpathAdditions);
if (ret == JD_OK)
is_java_vm_started = 1;
else
plugin_error("Could not start JavaVM!\n");
} else {
plugin_error("StartupJVM has already been called.\n");
}
ExitMonitor("StartupJVM");
return ret;
}
JavaPluginInstance5 *JavaPluginFactory5::GetInstance(int index) {
trace("JavaPluginFactory5:GetInstance\n");
JavaPluginInstance5* res;
EnterMonitor("GetInstance");
/* First handle the -1 index - pick a random instance */
if (index == -1) {
for (int i = 0; i < PLUGIN_INSTANCE_COUNT; i++) {
if (plugin_instances[i] != (JavaPluginInstance5 *)NULL) {
if (tracing)
trace("JavaPluginFactory5::Chose random instance %d\n", i);
ExitMonitor("GetInstance-any");
return plugin_instances[i];
}
}
trace("JavaPluginFactory5:Returning NULL for random instance");
return (JavaPluginInstance5 *)NULL;
}
/* For a non-random index, check bounds */
if ((index < 0) || (index >= PLUGIN_INSTANCE_COUNT)) {
plugin_error("Plugin instance index out of bounds %d\n", index);
res = (JavaPluginInstance5 *)NULL;
} else {
res = (JavaPluginInstance5 *) plugin_instances[index];
if (res == NULL)
trace("JavaPluginFactory::CreateInstance Returning a NULL instance! %d\n", index);
}
ExitMonitor("GetInstance-normal");
return res;
}
void JavaPluginFactory5::SendRequest(const CWriteBuffer& wb, int wait_for_reply)
{
EnterMonitor("SendRequest");
if (is_java_vm_started)
javaVM->SendRequest(wb, wait_for_reply);
else {
plugin_error("VM is not yet started up in SendRequest!");
}
ExitMonitor("SendRequest");
}
unsigned
PutPipeTimed(Pipe_t *p, void *data, unsigned size, unsigned msecs)
{
unsigned nbytes;
char *d;
if ( !size || !EnterMonitor(p->monitor) )
return 0;
// No se pueden escribir más bytes que el tamaño del pipe
if ( size > p->size )
size = p->size;
// Si hay un timeout finito, calcular deadline.
Time_t deadline = (msecs && msecs != FOREVER) ? Time() + msecs : 0;
// Para que la escritura sea atómica, esperar a que haya lugar para escribir todos los bytes
while ( (p->size - p->avail) < size )
{
// Desistir si es condicional, si no esperar
if ( !msecs || !WaitConditionTimed(p->cond_put, msecs) )
{
LeaveMonitor(p->monitor);
return 0;
}
// Si hay que seguir esperando con deadline, recalcular timeout
if ( deadline && (p->size - p->avail) < size )
{
Time_t now = Time();
msecs = now < deadline ? deadline - now : 0;
}
}
// Hay por lo menos size bytes libres, escribir
nbytes = size;
d = data;
while ( size-- )
{
*p->tail++ = *d++;
if ( p->tail == p->end )
p->tail = p->buf;
}
// Despertar eventuales lectores bloqueados
if ( !p->avail )
BroadcastCondition(p->cond_get);
p->avail += nbytes;
// Retornar cantidad de bytes escritos
LeaveMonitor(p->monitor);
return nbytes;
}
/* Free the index assocaited with the remote env 'env'. Should be called
when the remote env is destroyed, which should be when the securejni
is destroyed */
int
JavaPluginFactory5::UnregisterRemoteEnv(RemoteJNIEnv* env) {
EnterMonitor("Register Env");
for(int i = 0; i < MAX_ENVS; i++) {
if (current_envs[i] == env) {
current_envs[i] = NULL;
current_proxy_envs[i] = NULL;
ExitMonitor("Register Env");
return i;
}
}
ExitMonitor("Register Env");
plugin_error("No such env found!");
return -1;
}
void
consumer(void *arg)
{
char *name = arg;
while ( true )
{
EnterMonitor(mon);
while ( !key )
WaitCondition(cond);
printf("%s: key %c\n", name, key);
key = 0;
SignalCondition(cond);
LeaveMonitor(mon);
}
}
/* Register an env and return an index associated with that env.
This index should not be used directly, but may be useful for
debugging purposes. We also associate the current thread with
'env' */
int
JavaPluginFactory5::RegisterRemoteEnv(RemoteJNIEnv* env, JNIEnv* proxy_env) {
EnterMonitor("Register Env");
for(int i = 0; i < MAX_ENVS; i++) {
if (current_envs[i] == NULL) {
current_envs[i] = env;
current_proxy_envs[i] = proxy_env;
trace("JavaPluginFactory5: Register Env [%d] proxyenv=%d\n", i, (int) proxy_env);
ExitMonitor("Register Env");
return i;
}
}
ExitMonitor("Register Env");
plugin_error("Env table is full!");
return -1;
}
unsigned
GetPipeTimed(Pipe_t *p, void *data, unsigned size, unsigned msecs)
{
unsigned i, nbytes;
char *d;
if ( !size || !EnterMonitor(p->monitor) )
return 0;
// Si hay un timeout finito, calcular deadline.
Time_t deadline = (msecs && msecs != FOREVER) ? Time() + msecs : 0;
// Bloquearse si el pipe está vacío
while ( !p->avail )
{
// Desistir si es condicional, si no esperar
if ( !msecs || !WaitConditionTimed(p->cond_get, msecs) )
{
LeaveMonitor(p->monitor);
return 0;
}
// Si hay que seguir esperando con deadline, recalcular timeout
if ( deadline && !p->avail )
{
Time_t now = Time();
msecs = now < deadline ? deadline - now : 0;
}
}
// Leer lo que se pueda
for ( nbytes = min(size, p->avail), d = data, i = 0 ; i < nbytes ; i++ )
{
*d++ = *p->head++;
if ( p->head == p->end )
p->head = p->buf;
}
// Despertar eventuales escritores bloqueados
BroadcastCondition(p->cond_put);
p->avail -= nbytes;
// Retornar cantidad de bytes leídos
LeaveMonitor(p->monitor);
return nbytes;
}
bool
WaitConditionTimed(Condition_t *cond, unsigned msecs)
{
bool success;
Monitor_t *mon = cond->monitor;
if ( mon->owner != mt_curr_task )
Panic("WaitConditionTimed %s: la tarea no posee el monitor %s", GetName(cond), GetName(cond->monitor));
Atomic();
LeaveMonitor(mon);
success = WaitQueueTimed(&cond->queue, msecs);
while ( !EnterMonitor(mon) ) // Hay que volver a tomar el monitor si o si
;
Unatomic();
return success;
}
/*
* Plugin Internal: Unregister an instance from the internal table.
*/
void
JavaPluginFactory5::UnregisterInstance(JavaPluginInstance5 * pluginInstance) {
int i;
EnterMonitor("UnregisterInstance.");
int plugin_number = pluginInstance->GetPluginNumber();
trace("JavaPluginFactory5::Unregistering %d \n", plugin_number);
for (i = 0; i < PLUGIN_INSTANCE_COUNT; i++) {
if (plugin_instances[i] == pluginInstance) {
trace("JavaPluginFactory::Unregistering instance %d\n", i);
plugin_instances[i] = NULL;
ExitMonitor("UnregisterInstance-a");
return;
}
}
trace("JavaPluginFactory5::Plugin: couldn't find plugin_instance %d\n", plugin_number);
ExitMonitor("UnregisterInstance-b");
return;
}
/*
* Plugin Internal: Register an instance with the plugin We would like
* to be able to recover PluginInstances from the plugin. So we keep
* a registry of currently running instances. We provide the functions
* to register, unregister, and get a plugin instance from that
* registry.
*/
int
JavaPluginFactory5::RegisterInstance(JavaPluginInstance5* pluginInstance) {
trace("JavaPluginFactory5:RegisterInstance\n");
int i;
EnterMonitor("RegisterInstance");
for (i = 0; i < PLUGIN_INSTANCE_COUNT; i++) {
if (plugin_instances[i] == NULL) {
trace("JavaPluginFactory5::RegisterInstance %d at %d\n",
(int) pluginInstance, i);
plugin_instances[i] = pluginInstance;
ExitMonitor("RegisterInstance");
return i;
}
}
plugin_error("Could not register plugininstance\n");
ExitMonitor("RegisterInstance");
return JD_ERROR_FAILURE;
}
int
main(void)
{
mon = CreateMonitor("dos");
cond = CreateCondition("key", mon);
Ready(CreateTask(consumer, 2000, "consumer", "consumer", DEFAULT_PRIO));
while ( true )
{
EnterMonitor(mon);
while ( key )
WaitCondition(cond);
key = getch();
if ( key == 'S' || key == 's' )
return 0;
SignalCondition(cond);
LeaveMonitor(mon);
}
}
/* Create a new applet, with a particular index */
void
JavaPluginFactory5::CreateApplet(const char* appletType, int appletNumber,
int argc, char **argn, char **argv) {
trace("JavaPluginFactory5:CreateApplet\n");
/* Not sure if calling create applet is permitted before startup */
while (!is_java_vm_started) {
plugin_error("CreateApplet called before the VM is started\n?");
sleep(1);
}
EnterMonitor("CreateApplet");
/* The VM could have been shutdown again */
if (is_java_vm_started) {
trace("JavaPluginFactory5::CreateApplet %d \n", appletNumber);
javaVM->CreateApplet(appletType, appletNumber, argc, argn, argv);
} else {
plugin_error("VM not initialized. Cannot create applet!");
}
ExitMonitor("CreateApplet");
}
