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;
}
}
static void hidp_recv_ctrl_hid_control(struct input_device *idev, uint8_t param)
{
DBG("");
if (param == HIDP_CTRL_VIRTUAL_CABLE_UNPLUG)
connection_disconnect(idev, 0);
}
void connection_deinit(struct connection *conn)
{
i_assert(conn->list->connections_count > 0);
conn->list->connections_count--;
DLLIST_REMOVE(&conn->list->connections, conn);
connection_disconnect(conn);
i_free(conn->name);
}
static void memcached_conn_destroy(struct connection *_conn)
{
struct memcached_connection *conn = (struct memcached_connection *)_conn;
conn->dict->connected = FALSE;
connection_disconnect(_conn);
if (conn->dict->ioloop != NULL)
io_loop_stop(conn->dict->ioloop);
}
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 disconnect_cb(struct btd_device *device, gboolean removal,
void *user_data)
{
struct input_device *idev = user_data;
int flags;
info("Input: disconnect %s", idev->path);
flags = removal ? (1 << HIDP_VIRTUAL_CABLE_UNPLUG) : 0;
connection_disconnect(idev, flags);
}
int input_device_disconnect(struct btd_service *service)
{
struct input_device *idev;
int err;
DBG("");
idev = btd_service_get_user_data(service);
err = connection_disconnect(idev, 0);
if (err < 0)
return err;
return 0;
}
static int disconnect(struct input_device *idev, uint32_t flags)
{
struct input_conn *iconn = NULL;
GSList *l;
for (l = idev->connections; l; l = l->next) {
iconn = l->data;
if (is_connected(iconn))
break;
}
if (!iconn)
return ENOTCONN;
return connection_disconnect(iconn, flags);
}
static void
client_free(void *ctx)
{
struct connection *c = ctx;
assert(c->client.client != NULL);
if (c->autoreconnect && c->in_game) {
log(2, "server disconnected, auto-reconnecting\n");
connection_speak_console(c, "uoproxy was disconnected, auto-reconnecting...");
connection_disconnect(c);
connection_reconnect_delayed(c);
} else {
log(1, "server disconnected\n");
connection_delete(c);
}
}
int input_device_disconnect(struct btd_service *service)
{
struct input_device *idev;
int err, flags;
DBG("");
idev = btd_service_get_user_data(service);
flags = device_is_temporary(idev->device) ?
(1 << HIDP_VIRTUAL_CABLE_UNPLUG) : 0;
err = connection_disconnect(idev, flags);
if (err < 0)
return err;
return 0;
}
static int
client_packet(const void *data, size_t length, void *ctx)
{
struct connection *c = ctx;
packet_action_t action;
struct linked_server *ls;
assert(c->client.client != NULL);
action = handle_packet_from_server(server_packet_bindings,
c, data, length);
switch (action) {
case PA_ACCEPT:
if (!c->client.reconnecting)
list_for_each_entry(ls, &c->servers, siblings)
if (!ls->attaching && !ls->is_zombie)
uo_server_send(ls->server, data, length);
break;
case PA_DROP:
break;
case PA_DISCONNECT:
log(2, "aborting connection to server after packet 0x%x\n",
*(const unsigned char*)data);
log_hexdump(6, data, length);
if (c->autoreconnect && c->in_game) {
log(2, "auto-reconnecting\n");
connection_disconnect(c);
connection_reconnect_delayed(c);
} else {
connection_delete(c);
}
return -1;
case PA_DELETED:
return -1;
}
return 0;
}
static void
connection_free(struct connection *c)
{
struct linked_server *ls, *n;
connection_check(c);
list_for_each_entry_safe(ls, n, &c->servers, siblings)
connection_server_dispose(c, ls);
connection_disconnect(c);
if (c->client.reconnecting)
event_del(&c->client.reconnect_event);
client_version_free(&c->client_version);
poison(c, sizeof(*c));
free(c);
}
static DBusMessage *local_disconnect(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct network_peer *peer = data;
GSList *l;
for (l = peer->connections; l; l = l->next) {
struct network_conn *nc = l->data;
int err;
if (nc->state == DISCONNECTED)
continue;
err = connection_disconnect(nc->service);
if (err < 0)
return btd_error_failed(msg, strerror(-err));
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
return btd_error_not_connected(msg);
}
