GIO / Client Client Socket Example

Question

I would like to create a server and client application that communicates via sockets using GIO. GSocketService and GSocketClient seem ideal for this purpose, but unfortunately I could not find any tutorial or sample code (which GLib, GIO, ... newbie can understand). Does anyone know some good resources or can post sample code here?

Answer 1

I finally managed to create a simple server and client using glib and gio.
My server looks like this:

#include <glib.h> #include <gio/gio.h> /* this function will get called everytime a client attempts to connect */ gboolean incoming_callback (GSocketService *service, GSocketConnection *connection, GObject *source_object, gpointer user_data) { g_print("Received Connection from client!\n"); GInputStream * istream = g_io_stream_get_input_stream (G_IO_STREAM (connection)); gchar message[1024]; g_input_stream_read (istream, message, 1024, NULL, NULL); g_print("Message was: \"%s\"\n", message); return FALSE; } int main (int argc, char **argv) { /* initialize glib */ g_type_init(); GError * error = NULL; /* create the new socketservice */ GSocketService * service = g_socket_service_new (); /* connect to the port */ g_socket_listener_add_inet_port ((GSocketListener*)service, 1500, /* your port goes here */ NULL, &error); /* don't forget to check for errors */ if (error != NULL) { g_error (error->message); } /* listen to the 'incoming' signal */ g_signal_connect (service, "incoming", G_CALLBACK (incoming_callback), NULL); /* start the socket service */ g_socket_service_start (service); /* enter mainloop */ g_print ("Waiting for client!\n"); GMainLoop *loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(loop); return 0; } 

and this is the corresponding client:

 #include <glib.h> #include <gio/gio.h> int main (int argc, char *argv[]) { /* initialize glib */ g_type_init (); GError * error = NULL; /* create a new connection */ GSocketConnection * connection = NULL; GSocketClient * client = g_socket_client_new(); /* connect to the host */ connection = g_socket_client_connect_to_host (client, (gchar*)"localhost", 1500, /* your port goes here */ NULL, &error); /* don't forget to check for errors */ if (error != NULL) { g_error (error->message); } else { g_print ("Connection successful!\n"); } /* use the connection */ GInputStream * istream = g_io_stream_get_input_stream (G_IO_STREAM (connection)); GOutputStream * ostream = g_io_stream_get_output_stream (G_IO_STREAM (connection)); g_output_stream_write (ostream, "Hello server!", /* your message goes here */ 13, /* length of your message */ NULL, &error); /* don't forget to check for errors */ if (error != NULL) { g_error (error->message); } return 0; } 

Note that I'm still new to glib, gio, and even C, so double check your code before using it.

Answer 2

The inbound callback should not be blocked from the gio documentation: "The handler should initiate the processing of the connection, but cannot be blocked, in fact, asynchronous operations should be used."

I had a problem with the connection in the asynchronous version, it must be passed by the user or the connection will close after the incoming callback returns.

A complete example of a server that does not block, based on the above example:

 #include <gio/gio.h> #include <glib.h> #define BLOCK_SIZE 1024 #define PORT 2345 struct ConnData { GSocketConnection *connection; char message[BLOCK_SIZE]; }; void message_ready (GObject * source_object, GAsyncResult *res, gpointer user_data) { GInputStream *istream = G_INPUT_STREAM (source_object); GError *error = NULL; struct ConnData *data = user_data; int count; count = g_input_stream_read_finish (istream, res, &error); if (count == -1) { g_error ("Error when receiving message"); if (error != NULL) { g_error ("%s", error->message); g_clear_error (&error); } } g_message ("Message was: \"%s\"\n", data->message); g_object_unref (G_SOCKET_CONNECTION (data->connection)); g_free (data); } static gboolean incoming_callback (GSocketService *service, GSocketConnection * connection, GObject * source_object, gpointer user_data) { g_message ("Received Connection from client!\n"); GInputStream *istream = g_io_stream_get_input_stream (G_IO_STREAM (connection)); struct ConnData *data = g_new (struct ConnData, 1); data->connection = g_object_ref (connection); g_input_stream_read_async (istream, data->message, sizeof (data->message), G_PRIORITY_DEFAULT, NULL, message_ready, data); return FALSE; } int main () { GSocketService *service; GError *error = NULL; gboolean ret; service = g_socket_service_new (); ret = g_socket_listener_add_inet_port (G_SOCKET_LISTENER (service), PORT, NULL, &error); if (ret && error != NULL) { g_error ("%s", error->message); g_clear_error (&error); return 1; } g_signal_connect (service, "incoming", G_CALLBACK (incoming_callback), NULL); g_socket_service_start (service); GMainLoop *loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(loop); /* Stop service when out of the main loop*/ g_socket_service_stop (service); return 0; }