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"); }