Beispiel #1
0
    static void JNICALL
    object_free(jvmtiEnv* jvmti, jlong tag) {
	jvmti->RawMonitorEnter(vm_death_lock); {
	    if ( !vm_death_active ) {
		get_agent(jvmti)->object_free(jvmti, tag);
	    }
	} jvmti->RawMonitorExit(vm_death_lock);
    }
Beispiel #2
0
    static void JNICALL
    thread_end(jvmtiEnv *jvmti, JNIEnv *env, jthread thread) {
	jvmti->RawMonitorEnter(vm_death_lock); {
	    if ( !vm_death_active ) {
		get_agent(jvmti)->thread_end(jvmti, env, thread);
	    }
	} jvmti->RawMonitorExit(vm_death_lock);
    }
Beispiel #3
0
 static void JNICALL
 object_free(jvmtiEnv* jvmti, jlong tag)
 {
     menter(jvmti, vm_death_lock); {
         if ( !vm_death_active ) {
             get_agent(jvmti)->object_free(jvmti, tag);
         }
     } mexit(jvmti, vm_death_lock);
 }
Beispiel #4
0
 static void JNICALL
 thread_end(jvmtiEnv *jvmti, JNIEnv *env, jthread thread)
 {
     menter(jvmti, vm_death_lock); {
         if ( !vm_death_active ) {
             get_agent(jvmti)->thread_end(jvmti, env, thread);
         }
     } mexit(jvmti, vm_death_lock);
 }
Beispiel #5
0
    static void JNICALL
    monitor_waited(jvmtiEnv* jvmti, JNIEnv *env,
		   jthread thread, jobject object, jboolean timed_out) {
	jvmti->RawMonitorEnter(vm_death_lock); {
	    if ( !vm_death_active ) {
		get_agent(jvmti)->monitor_waited(jvmti, env, thread, 
					         object, timed_out);
	    }
	} jvmti->RawMonitorExit(vm_death_lock);
    }
Beispiel #6
0
    static void JNICALL
    monitor_contended_entered(jvmtiEnv* jvmti, JNIEnv *env,
		   jthread thread, jobject object) {
	jvmti->RawMonitorEnter(vm_death_lock); {
	    if ( !vm_death_active ) {
		get_agent(jvmti)->monitor_contended_entered(jvmti, env, 
							    thread, object);
	    }
	} jvmti->RawMonitorExit(vm_death_lock);
    }
Beispiel #7
0
 static void JNICALL
 monitor_wait(jvmtiEnv* jvmti, JNIEnv *env,
              jthread thread, jobject object, jlong timeout)
 {
     menter(jvmti, vm_death_lock); {
         if ( !vm_death_active ) {
             get_agent(jvmti)->monitor_wait(jvmti, env, thread,
                                            object, timeout);
         }
     } mexit(jvmti, vm_death_lock);
 }
Beispiel #8
0
void
SearchResultsMgr::display (ResultID *results)
{
    SearchResultsAgent *sra = get_agent();

    // NOTE: error checking
    // NOTE: save in f_active_agents
    sra->display (results);

    setStatus (eSuccess);
}
JNIEXPORT void JNICALL Java_jp_marisa_AgentNative_dispose(JNIEnv *env, jobject pthis) {
	marisa::Agent* native_agent = get_agent(env, pthis);
	if (native_agent != NULL) {
		delete native_agent;
	}

	set_handle_value(env, pthis, "Ljp/marisa/AgentNative;", (jlong)-1);

	jlong handle = get_stringBufferHandle_value(env, pthis);
	if (handle != -1) {
		delete [] (char *)handle;
	}
	set_stringBufferHandle_value(env, pthis, (jlong)-1);
}
Beispiel #10
0
    static void JNICALL
    vm_death(jvmtiEnv *jvmti, JNIEnv *env) {
        Agent               *agent;

	/* Block all callbacks */
	jvmti->RawMonitorEnter(vm_death_lock); {
	    /* Set flag for other callbacks */
	    vm_death_active = JNI_TRUE;

	    /* Inform Agent instance of VM_DEATH */
	    agent = get_agent(jvmti);
	    agent->vm_death(jvmti, env);

	    /* Reclaim space of Agent */
	    jvmti->SetEnvironmentLocalStorage((const void*)NULL);
	    delete agent;
	} jvmti->RawMonitorExit(vm_death_lock);

    }
JNIEXPORT jobject JNICALL Java_jp_marisa_AgentNative_query(JNIEnv *env, jobject pthis) {
	marisa::Agent* native_agent = get_agent(env, pthis);
	if (native_agent == NULL) {
		return NULL;
	}

	try {
		const marisa::Query& query = native_agent->query();

		jobject obj = attach_handle(env, "Ljp/marisa/QueryNative;", (jlong)&query);
		return obj;
	} catch (const marisa::Exception& ex) {
		// TODO:
		jclass clsj = env->FindClass("Ljava/lang/UnsupportedOperationException;");
		if (clsj == NULL)
			return NULL;

		env->ThrowNew(clsj, ex.error_message());
		env->DeleteLocalRef(clsj);
		return NULL;
	}
}
Beispiel #12
0
    static void JNICALL
    vm_death(jvmtiEnv *jvmti, JNIEnv *env)
    {
        jvmtiError err;
        Agent     *agent;

        /* Block all callbacks */
        menter(jvmti, vm_death_lock); {
            /* Set flag for other callbacks */
            vm_death_active = JNI_TRUE;

            /* Inform Agent instance of VM_DEATH */
            agent = get_agent(jvmti);
            agent->vm_death(jvmti, env);

            /* Reclaim space of Agent */
            err = jvmti->SetEnvironmentLocalStorage((const void*)NULL);
            check_jvmti_error(jvmti, err, "set env local storage");
            delete agent;
        } mexit(jvmti, vm_death_lock);

    }
std::pair< Wt::WWidget*, Wt::WWidget* > generic_sys_coordinator::initialize()
{
	std::lock_guard< std::mutex > guard(m_sys_mutex);

	m_widget = new sys_display_widget(m_sys_mutex);
	//m_widget->set_drawer(m_sys->get_drawer());
	m_widget->interactive_input_sig().connect(this, &generic_sys_coordinator::on_widget_interaction);

	// TODO: This seems hacky, but don't want the selected series to be reset on restart,
	// since the system type is unchanged and therefore so are the properties
	auto temp_sys = m_sys_factory->create_system();
	temp_sys->initialize();
	for(auto const& agent : m_agents_spec.agents)
	{
		auto agent_id = temp_sys->register_agent(agent.spec);// , std::move(controller));
		auto controller = std::unique_ptr< rtp::i_controller >(
			m_agents_spec.controller_factories[agent.controller_id]->create(&temp_sys->get_agent(agent_id))
			);
		temp_sys->register_agent_controller(agent_id, std::move(controller));
	}

	Wt::WWidget* props_wt_wgt = nullptr;
	if(temp_sys->is_instantaneous())
	{
		auto wgt = new properties_table_widget{};
		m_props_widget = wgt;
		props_wt_wgt = wgt;
	}
	else
	{
		auto wgt = new properties_chart_widget{};
		m_props_widget = wgt;
		props_wt_wgt = wgt;
	}
	m_props_widget->reset(temp_sys->get_state_properties());

	return std::pair< Wt::WWidget*, Wt::WWidget* >(m_widget, props_wt_wgt);
}
Beispiel #14
0
int main(int argc, char *argv[])
{
    bool source = true;
    struct agent_data_t data;
    char *password = NULL;
    enum action verb = ACTION_NONE;
    enum agent type = AGENT_DEFAULT;
    void (*print_env)(struct agent_data_t *data) = print_sh_env;

    static const struct option opts[] = {
        { "help",    no_argument,       0, 'h' },
        { "version", no_argument,       0, 'v' },
        { "add",     no_argument,       0, 'a' },
        { "clear",   no_argument,       0, 'k' },
        { "kill",    no_argument,       0, 'K' },
        { "list",    no_argument,       0, 'l' },
        { "unlock",  optional_argument, 0, 'u' },
        { "print",   no_argument,       0, 'p' },
        { "sh",      no_argument,       0, 's' },
        { "csh",     no_argument,       0, 'c' },
        { "fish",    no_argument,       0, 'f' },
        { "agent",   required_argument, 0, 't' },
        { 0, 0, 0, 0 }
    };

    while (true) {
        int opt = getopt_long(argc, argv, "hvakKlu::pscft:", opts, NULL);
        if (opt == -1)
            break;

        switch (opt) {
        case 'h':
            usage(stdout);
            break;
        case 'v':
            printf("%s %s\n", program_invocation_short_name, ENVOY_VERSION);
            return 0;
        case 'a':
            verb = ACTION_FORCE_ADD;
            break;
        case 'k':
            verb = ACTION_CLEAR;
            source = false;
            break;
        case 'K':
            verb = ACTION_KILL;
            source = false;
            break;
        case 'l':
            verb = ACTION_LIST;
            break;
        case 'u':
            verb = ACTION_UNLOCK;
            password = optarg;
            break;
        case 'p':
            verb = ACTION_PRINT;
            break;
        case 's':
            print_env = print_sh_env;
            break;
        case 'c':
            print_env = print_csh_env;
            break;
        case 'f':
            print_env = print_fish_env;
            break;
        case 't':
            type = lookup_agent(optarg);
            if (type < 0)
                errx(EXIT_FAILURE, "unknown agent: %s", optarg);
            break;
        default:
            usage(stderr);
        }
    }

    if (get_agent(&data, type, source) < 0)
        errx(EXIT_FAILURE, "recieved no data, did the agent fail to start?");

    if (data.status == ENVOY_STOPPED)
        return 0;

    if (source)
        source_env(&data);

    switch (verb) {
    case ACTION_PRINT:
        print_env(&data);
        /* fall through */
    case ACTION_NONE:
        if (data.status != ENVOY_STARTED || data.type == AGENT_GPG_AGENT)
            break;
        /* fall through */
    case ACTION_FORCE_ADD:
        add_keys(&argv[optind], argc - optind);
        break;
    case ACTION_CLEAR:
        if (data.type == AGENT_GPG_AGENT)
            kill(data.pid, SIGHUP);
        else
            errx(EXIT_FAILURE, "only gpg-agent supports this operation");
        break;
    case ACTION_KILL:
        kill(data.pid, SIGTERM);
        break;
    case ACTION_LIST:
        execlp("ssh-add", "ssh-add", "-l", NULL);
        err(EXIT_FAILURE, "failed to launch ssh-add");
    case ACTION_UNLOCK:
        unlock(&data, password);
        break;
    default:
        break;
    }

    return 0;
}
Beispiel #15
0
int main(int argc, char *argv[])
{
    bool source = true;
    bool defer = false;
    struct agent_data_t data;
    char *password = NULL;
    enum action verb = ACTION_NONE;
    enum agent type = AGENT_DEFAULT;
    void (*print_env)(struct agent_data_t *data) = print_sh_env;

    static const struct option opts[] = {
        { "help",    no_argument,       0, 'h' },
        { "version", no_argument,       0, 'v' },
        { "defer",   no_argument,       0, 'd' },
        { "add",     no_argument,       0, 'a' },
        { "expunge", no_argument,       0, 'x' },
        { "kill",    no_argument,       0, 'k' },
        { "reload",  no_argument,       0, 'r' },
        { "list",    no_argument,       0, 'l' },
        { "unlock",  optional_argument, 0, 'u' },
        { "print",   no_argument,       0, 'p' },
        { "sh",      no_argument,       0, 's' },
        { "csh",     no_argument,       0, 'c' },
        { "fish",    no_argument,       0, 'f' },
        { "agent",   required_argument, 0, 't' },
        { 0, 0, 0, 0 }
    };

    while (true) {
        int opt = getopt_long(argc, argv, "hvdaxkrlu::pscft:", opts, NULL);
        if (opt == -1)
            break;

        switch (opt) {
        case 'h':
            usage(stdout);
            break;
        case 'v':
            printf("%s %s\n", program_invocation_short_name, ENVOY_VERSION);
            return 0;
        case 'd':
            defer = true;
            break;
        case 'a':
            verb = ACTION_FORCE_ADD;
            defer = false;
            break;
        case 'x':
            verb = ACTION_FORCE_EXPUNGE;
            defer = false;
            break;
        case 'k':
            verb = ACTION_KILL;
            source = false;
            break;
        case 'r':
            verb = ACTION_RELOAD;
            source = false;
            break;
        case 'l':
            verb = ACTION_LIST;
            break;
        case 'u':
            verb = ACTION_UNLOCK;
            password = optarg;
            break;
        case 'p':
            verb = ACTION_PRINT;
            break;
        case 's':
            print_env = print_sh_env;
            break;
        case 'c':
            print_env = print_csh_env;
            break;
        case 'f':
            print_env = print_fish_env;
            break;
        case 't':
            type = lookup_agent(optarg);
            if (type < 0)
                errx(EXIT_FAILURE, "unknown agent: %s", optarg);
            break;
        default:
            usage(stderr);
        }
    }

    if (get_agent(&data, type, source, defer) < 0)
        errx(EXIT_FAILURE, "recieved no data, did the agent fail to start?");

    if (data.status == ENVOY_STOPPED)
        return 0;

    if (source)
        source_env(&data);

    switch (verb) {
    case ACTION_PRINT:
        print_env(&data);
        /* fall through */
    case ACTION_NONE:
        if (data.type == AGENT_GPG_AGENT || !agent_started(&data))
            break;
        if (defer)
            break;
        /* fall through */
    case ACTION_FORCE_ADD:
        add_keys(&argv[optind], argc - optind);
        break;
    case ACTION_FORCE_EXPUNGE:
        expunge_keys(&argv[optind], argc - optind);
        break;
    case ACTION_KILL:
        if (envoy_kill_agent(type) < 0)
            errx(EXIT_FAILURE, "failed to kill agent");
        break;
    case ACTION_RELOAD:
        reload_agent(&data);
        break;
    case ACTION_LIST:
        execlp("ssh-add", "ssh-add", "-l", NULL);
        err(EXIT_FAILURE, "failed to launch ssh-add");
    case ACTION_UNLOCK:
        unlock(&data, password);
        break;
    default:
        break;
    }

    return 0;
}