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