void lllp_connected_cb(GObject *listener, GAsyncResult *res, gpointer pstore_library) {
	GtkListStore *store_library = GTK_LIST_STORE(pstore_library);
	GSocketConnection *connection;
	GSocketAddress *address;
	gchar *address_char;
	GInputStream *stream;
	GFile *output_file;
	GOutputStream *file_stream;
	gsize count;
	gboolean valid = FALSE;


	connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(listener), res, NULL, NULL);
	address = g_socket_connection_get_remote_address(connection, NULL);
	address_char = g_inet_address_to_string(g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(address)));
	printf("%s\n", address_char);

	output_file = g_file_new_for_path(address_char);
	g_file_delete(output_file, NULL, NULL);
	file_stream = (GOutputStream*)g_file_replace(output_file, NULL, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL, NULL);

	stream = g_io_stream_get_input_stream(G_IO_STREAM(connection));
	g_output_stream_splice(file_stream, stream, 
		G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE & G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, NULL);
	g_output_stream_close(file_stream, NULL, NULL);

	convert_library_to_list_store(store_library, address_char);

	printf("%s CONNECTED\n", address_char);

	g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_connected_cb, store_library);
}
void lllp_quit_cb(GObject *listener, GAsyncResult *res, gpointer pstore_library) {
	GtkListStore *store_library = GTK_LIST_STORE(pstore_library);
	gsize i;
	GtkTreeIter iter;
	gboolean valid;
	GSocketConnection *connection;
	GSocketAddress *remote_socket_addr;
	GInetAddress *remote_addr;
	gchar *remote_addr_char;
	gchar *tempchar;

	connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(listener), res, NULL, NULL);
	remote_socket_addr = g_socket_connection_get_remote_address(connection, NULL);
	remote_addr = g_inet_socket_address_get_address((GInetSocketAddress *)(remote_socket_addr));
	remote_addr_char = g_inet_address_to_string(remote_addr);

	if(connection != NULL) {
		valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store_library), &iter);
		while(valid == TRUE) {
			gtk_tree_model_get(GTK_TREE_MODEL(store_library), &iter, INET_ADDRESS, &tempchar, -1);
			if(g_strcmp0(tempchar, remote_addr_char) == 0)
				gtk_list_store_remove(store_library, &iter);
			valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store_library), &iter);
		}
		
		printf("LLLP %s DISCONNECTED\n", remote_addr_char);
	}
	g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_quit_cb, store_library);
}
Esempio n. 3
0
static void
create_tube_socket_connected_cb (GObject *source_object,
    GAsyncResult *res,
    gpointer user_data)
{
  GSimpleAsyncResult *simple = user_data;
  CreateTubeData *data;
  GSocketListener *listener = G_SOCKET_LISTENER (source_object);
  GError *error = NULL;

  data = g_simple_async_result_get_op_res_gpointer (simple);

  if (g_cancellable_is_cancelled (data->op_cancellable))
    {
      g_object_unref (simple);
      return;
    }

  data->connection = g_socket_listener_accept_finish (listener, res, NULL,
      &error);

  if (data->connection != NULL)
    {
      /* Transfer ownership of unix path */
      g_object_set_data_full (G_OBJECT (data->connection), "unix-path",
          data->unix_path, (GDestroyNotify) unix_path_destroy);
      data->unix_path = NULL;
    }

  create_tube_complete (simple, error);

  g_clear_error (&error);
  g_object_unref (simple);
}
GIOStream*
spice_foreign_menu_listener_accept_finish (GObject *listener,
                                           GAsyncResult *result,
                                           GObject **source_object,
                                           GError **error)
{
    g_return_val_if_fail(G_IS_OBJECT(listener), NULL);

#ifdef G_OS_WIN32
    SpiceNamedPipeConnection *np;
    np = spice_named_pipe_listener_accept_finish (SPICE_NAMED_PIPE_LISTENER (listener), result, source_object, error);
    if (np)
        return G_IO_STREAM (np);
#else
    GSocketConnection *socket;
    socket = g_socket_listener_accept_finish (G_SOCKET_LISTENER (listener), result, source_object, error);
    if (socket)
        return G_IO_STREAM (socket);
#endif

    return NULL;
}
void lllp_next_song_cb(GObject *listener, GAsyncResult *res, gpointer pstore_library) {
	GtkListStore *store_library = GTK_LIST_STORE(pstore_library);
	gboolean valid = FALSE;
	GSocketConnection *connection;
	GSocketClient *player_client;
	GSocketAddress *address;
	GSocket *socket;
	GInputStream *stream;
	GOutputStream *output_stream;
	GInetAddress *inet_address;
	GInetAddress *player_with_the_song;
	GtkTreeIter iter;
	gchar *player_with_the_song_char;
	struct force_vector_s force_vector;
	gchar *remote_file;
	gint random_number;
	gsize count = 0;
	int i;
	struct force_vector_s rand_force_vector;

	connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(listener), res, NULL, NULL);
	address = g_socket_connection_get_remote_address(connection, NULL);
	inet_address = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(address));

	socket = g_socket_connection_get_socket(connection);
	stream = g_io_stream_get_input_stream(G_IO_STREAM(connection));

	g_input_stream_read_all(stream, &force_vector, sizeof(force_vector), NULL, NULL, NULL);
	
	valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store_library), &iter);
	while(valid == TRUE) {
		valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store_library), &iter);
		count++;
	}

	gint rand;
	float distance = 100, old_distance = 100;
	float treshold = 0.95;
	float treshold_distance = 4.0;

	do {
		/* TO FUNCTIONALIZE */
		rand = g_random_int_range(0, count);

		if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store_library), &iter)) {
			for(i = 0; i < rand - 1; ++i) {
				gtk_tree_model_iter_next(GTK_TREE_MODEL(store_library), &iter);
			}
			gtk_tree_model_get(GTK_TREE_MODEL(store_library), &iter, FORCE_AMP, &rand_force_vector.amplitude,
				FORCE_ATK, &rand_force_vector.attack, FORCE_FREQ, &rand_force_vector.frequency,
				FORCE_TEMPO, &rand_force_vector.tempo, -1);
		}
		treshold -= 0.01;
		treshold_distance += 0.01;
	}  while((bl_cosine_similarity(rand_force_vector, force_vector) < treshold) ||
		((distance = bl_distance(rand_force_vector, force_vector)) > treshold_distance));
	
	gtk_tree_model_get(GTK_TREE_MODEL(store_library), &iter, AFILE, &remote_file, INET_ADDRESS, &player_with_the_song_char, -1);
	player_with_the_song = g_inet_address_new_from_string(player_with_the_song_char);

	if(g_inet_address_equal(player_with_the_song, inet_address) == TRUE) {
		rand_force_vector.attack = rand_force_vector.frequency = rand_force_vector.tempo = rand_force_vector.amplitude = 0;
		player_client = g_socket_client_new();
		connection = g_socket_client_connect_to_host(player_client, g_inet_address_to_string(inet_address), 5353, NULL, NULL);
		output_stream = g_io_stream_get_output_stream(G_IO_STREAM(connection));
		g_output_stream_write_all(output_stream, &rand_force_vector, sizeof(rand_force_vector), &count, NULL, NULL);
		g_io_stream_close(G_IO_STREAM(connection), NULL, NULL);

		g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_next_song_cb, store_library);
	
		return;
	}
	player_client = g_socket_client_new();
	connection = g_socket_client_connect_to_host(player_client, g_inet_address_to_string(inet_address), 5353, NULL, NULL);
	output_stream = g_io_stream_get_output_stream(G_IO_STREAM(connection));
	g_output_stream_write_all(output_stream, &rand_force_vector, sizeof(rand_force_vector), &count, NULL, NULL);
	g_io_stream_close(G_IO_STREAM(connection), NULL, NULL);

	player_with_the_song_char = g_inet_address_to_string(player_with_the_song);
	connection = g_socket_client_connect_to_host(player_client, player_with_the_song_char, 19144, NULL, NULL);
	printf("%p\n", connection);
	output_stream = g_io_stream_get_output_stream(G_IO_STREAM(connection));
	count = strlen(g_inet_address_to_string(inet_address)) + 1;
	g_output_stream_write_all(output_stream, &count, sizeof(gsize), NULL, NULL, NULL);
	g_output_stream_write_all(output_stream, g_inet_address_to_string(inet_address), count, NULL, NULL, NULL);
	count = strlen(remote_file) + 1;
	g_output_stream_write_all(output_stream, &count, sizeof(gsize), NULL, NULL, NULL);
	g_output_stream_write_all(output_stream, remote_file, count, NULL, NULL, NULL);
	g_output_stream_close(output_stream, NULL, NULL);

	g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_next_song_cb, store_library);
}