static void main_channel_event(SpiceChannel *channel, SpiceChannelEvent event,
gpointer data)
{
spice_connection *conn = data;
char password[64];
int rc = -1;
switch (event) {
case SPICE_CHANNEL_OPENED:
g_message("main channel: opened");
//recent_add(conn->session);
break;
case SPICE_CHANNEL_SWITCHING:
g_message("main channel: switching host");
break;
case SPICE_CHANNEL_CLOSED:
/* this event is only sent if the channel was succesfully opened before */
g_message("main channel: closed");
connection_disconnect(conn);
break;
case SPICE_CHANNEL_ERROR_IO:
connection_disconnect(conn);
break;
case SPICE_CHANNEL_ERROR_TLS:
case SPICE_CHANNEL_ERROR_LINK:
case SPICE_CHANNEL_ERROR_CONNECT:
g_message("main channel: failed to connect");
//rc = connect_dialog(conn->session);
if (rc == 0) {
connection_connect(conn);
} else {
connection_disconnect(conn);
}
break;
case SPICE_CHANNEL_ERROR_AUTH:
g_warning("main channel: auth failure (wrong password?)");
strcpy(password, "");
/* FIXME i18 */
//rc = ask_user(NULL, _("Authentication"),
// _("Please enter the spice server password"),
// password, sizeof(password), true);
if (rc == 0) {
g_object_set(conn->session, "password", password, NULL);
connection_connect(conn);
} else {
connection_disconnect(conn);
}
break;
default:
/* TODO: more sophisticated error handling */
g_warning("unknown main channel event: %d", event);
/* connection_disconnect(conn); */
break;
}
}
// Creates a new connection for client, associated with the host of
// client's database
static struct connection *connection_create(struct client *cl,
struct host *host,
int operation_timeout,
int session_timeout,
iochan_man_t iochan_man)
{
struct connection *co;
co = xmalloc(sizeof(*co));
co->host = host;
co->client = cl;
co->zproxy = 0;
client_set_connection(cl, co);
co->link = 0;
co->state = Conn_Closed;
co->operation_timeout = operation_timeout;
co->session_timeout = session_timeout;
if (host->ipport)
connection_connect(co, iochan_man);
yaz_mutex_enter(host->mutex);
co->next = co->host->connections;
co->host->connections = co;
yaz_mutex_leave(host->mutex);
connection_use(1);
return co;
}
static bool run(const options_t *options, transaction_t *transaction) {
bool ret = false;
connection_t *connection = NULL;
transaction_t reply;
connection = connection_new(options->host, options->port);
if (!connection) {
return EXIT_FAILURE;
}
ret = connection_connect(connection);
if (!ret) {
return ret;
}
switch (transaction->command) {
case STATUS: {
ret = status_command(connection, transaction);
break;
}
default: {
ret = default_send_receive(connection, transaction);
break;
}
}
return ret;
}
JNIEXPORT jint JNICALL
Java_com_iiordanov_aSPICE_SpiceCommunicator_SpiceClientConnect (JNIEnv *env, jobject obj, jstring h, jstring p,
jstring tp, jstring pw, jstring cf, jstring cs, jboolean sound)
{
int result = 0;
maintainConnection = TRUE;
soundEnabled = sound;
// Get a reference to the JVM to get JNIEnv from in (other) threads.
jint rs = (*env)->GetJavaVM(env, &jvm);
if (rs != JNI_OK) {
__android_log_write(6, "spicy", "ERROR: Could not obtain jvm reference.");
return 255;
}
// Find the jclass reference and get a Global reference for it for use in other threads.
jclass local_class = (*env)->FindClass (env, "com/iiordanov/aSPICE/SpiceCommunicator");
jni_connector_class = (jclass)((*env)->NewGlobalRef(env, local_class));
// Get global method IDs for callback methods.
jni_settings_changed = (*env)->GetStaticMethodID (env, jni_connector_class, "OnSettingsChanged", "(IIII)V");
jni_graphics_update = (*env)->GetStaticMethodID (env, jni_connector_class, "OnGraphicsUpdate", "(IIIII)V");
g_thread_init(NULL);
bindtextdomain(GETTEXT_PACKAGE, SPICE_GTK_LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
g_type_init();
mainloop = g_main_loop_new(NULL, false);
spice_connection *conn;
conn = connection_new();
spice_session_setup(env, conn->session, h, p, tp, pw, cf, cs);
//watch_stdin();
connection_connect(conn);
if (connections > 0) {
g_main_loop_run(mainloop);
connection_disconnect(conn);
g_object_unref(mainloop);
__android_log_write(6, "spicy", "Exiting main loop.");
} else {
__android_log_write(6, "spicy", "Wrong hostname, port, or password.");
result = 2;
}
jvm = NULL;
jni_connector_class = NULL;
jni_settings_changed = NULL;
jni_graphics_update = NULL;
return result;
}
static void *
test_conn_get_basic_setup(const struct testcase_t *tc)
{
connection_t *conn = NULL;
tor_addr_t addr;
int socket_err = 0;
int in_progress = 0;
(void)tc;
MOCK(connection_connect_sockaddr,
mock_connection_connect_sockaddr);
init_connection_lists();
conn = connection_new(TEST_CONN_TYPE, TEST_CONN_FAMILY);
tt_assert(conn);
test_conn_lookup_addr_helper(TEST_CONN_ADDRESS, TEST_CONN_FAMILY, &addr);
tt_assert(!tor_addr_is_null(&addr));
/* XXXX - connection_connect doesn't set these, should it? */
tor_addr_copy_tight(&conn->addr, &addr);
conn->port = TEST_CONN_PORT;
mock_connection_connect_sockaddr_called = 0;
in_progress = connection_connect(conn, TEST_CONN_ADDRESS_PORT, &addr,
TEST_CONN_PORT, &socket_err);
tt_assert(mock_connection_connect_sockaddr_called == 1);
tt_assert(!socket_err);
tt_assert(in_progress == 0 || in_progress == 1);
/* fake some of the attributes so the connection looks OK */
conn->state = TEST_CONN_STATE;
conn->purpose = TEST_CONN_BASIC_PURPOSE;
assert_connection_ok(conn, time(NULL));
UNMOCK(connection_connect_sockaddr);
return conn;
/* On failure */
done:
UNMOCK(connection_connect_sockaddr);
test_conn_get_basic_teardown(tc, conn);
/* Returning NULL causes the unit test to fail */
return NULL;
}
static connection_t *
test_conn_get_connection(uint8_t state, uint8_t type, uint8_t purpose)
{
connection_t *conn = NULL;
tor_addr_t addr;
int socket_err = 0;
int in_progress = 0;
MOCK(connection_connect_sockaddr,
mock_connection_connect_sockaddr);
MOCK(tor_close_socket, fake_close_socket);
init_connection_lists();
conn = connection_new(type, TEST_CONN_FAMILY);
tt_assert(conn);
test_conn_lookup_addr_helper(TEST_CONN_ADDRESS, TEST_CONN_FAMILY, &addr);
tt_assert(!tor_addr_is_null(&addr));
tor_addr_copy_tight(&conn->addr, &addr);
conn->port = TEST_CONN_PORT;
mock_connection_connect_sockaddr_called = 0;
in_progress = connection_connect(conn, TEST_CONN_ADDRESS_PORT, &addr,
TEST_CONN_PORT, &socket_err);
tt_assert(mock_connection_connect_sockaddr_called == 1);
tt_assert(!socket_err);
tt_assert(in_progress == 0 || in_progress == 1);
/* fake some of the attributes so the connection looks OK */
conn->state = state;
conn->purpose = purpose;
assert_connection_ok(conn, time(NULL));
UNMOCK(connection_connect_sockaddr);
UNMOCK(tor_close_socket);
return conn;
/* On failure */
done:
UNMOCK(connection_connect_sockaddr);
UNMOCK(tor_close_socket);
return NULL;
}
void connect_resolver_host(struct host *host, iochan_man_t iochan_man)
{
struct connection *con;
start:
yaz_mutex_enter(host->mutex);
con = host->connections;
while (con)
{
if (con->state == Conn_Closed)
{
if (!host->ipport) /* unresolved */
{
remove_connection_from_host(con);
yaz_mutex_leave(host->mutex);
connection_destroy(con);
goto start;
/* start all over .. at some point it will be NULL */
}
else if (!con->client)
{
remove_connection_from_host(con);
yaz_mutex_leave(host->mutex);
connection_destroy(con);
/* start all over .. at some point it will be NULL */
goto start;
}
else
{
yaz_mutex_leave(host->mutex);
connection_connect(con, iochan_man);
client_start_search(con->client);
goto start;
}
}
else
{
yaz_log(YLOG_LOG, "connect_resolver_host: state=%d", con->state);
con = con->next;
}
}
yaz_mutex_leave(host->mutex);
}
/*メインの流れ*/
int connection_main(void* data){
CONNECTION_DATA* con = (CONNECTION_DATA*)data;
int action_code;
int running = true;
//シグナルの受信
while(running && read(con->com_pipe[PIPE_READ],&action_code,sizeof(action_code))){
switch(action_code){
case MANAGER_ACTION_CONNECT:
read( con->com_pipe[PIPE_READ],
&con->socket,
sizeof(con->socket)
);
connection_connect(con);
break;
case MANAGER_ACTION_KILL:
running = false;
break;
}
}
connection_free(con);
return EXIT_SUCCESS;
}
static DBusMessage *local_connect(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct network_peer *peer = data;
struct btd_service *service;
struct network_conn *nc;
const char *svc;
const char *uuid;
uint16_t id;
int err;
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &svc,
DBUS_TYPE_INVALID) == FALSE)
return btd_error_invalid_args(msg);
id = bnep_service_id(svc);
uuid = bnep_uuid(id);
if (uuid == NULL)
return btd_error_invalid_args(msg);
service = btd_device_get_service(peer->device, uuid);
if (service == NULL)
return btd_error_not_supported(msg);
nc = btd_service_get_user_data(service);
if (nc->connect != NULL)
return btd_error_busy(msg);
err = connection_connect(nc->service);
if (err < 0)
return btd_error_failed(msg, strerror(-err));
nc->connect = dbus_message_ref(msg);
return NULL;
}
