C 异步GIO服务器/客户端

我想创建一个异步服务器和客户端应用程序，使用GIO通过套接字进行通信。由于我是GIO的新手，在浏览时我得到了以下代码——这是我的客户。我找不到该服务器的任何示例。请在这方面指导我

GMainLoop *loop;
GMainContext *ctx;

struct conn
{
    GSocketClient *client;

    GSocketConnection *conn;
    GInputStream *in;
    GOutputStream *out;

    gchar data[8192];
    unsigned int count;
};

static void
read_done_cb(GObject *source_object, GAsyncResult *res, gpointer user_data)
{

    printf("## %s\n", __FUNCTION__);

    struct conn *c = (struct conn *)user_data;
    gssize len = g_input_stream_read_finish(c->in, res, NULL);

    g_input_stream_read_async(c->in, c->data, sizeof c->data / sizeof *c->data, G_PRIORITY_DEFAULT, NULL, read_done_cb, c);
    if (c->count++ == 1) {
        printf("End of life as I know it...\n");
        g_main_loop_quit(loop);
    }
}

static void
write_done_cb(GObject *source_object, GAsyncResult *res, gpointer user_data)
{
}

static void
connect_done_cb(GObject *source_object, GAsyncResult *res, gpointer user_data)
{
    printf("## %s\n", __FUNCTION__);

    struct conn *c = (struct conn *)user_data;
    c->conn = g_socket_client_connect_to_host_finish(c->client, res, NULL);

    printf("I'm\n");
    c->in  = g_io_stream_get_input_stream(G_IO_STREAM (c->conn));
    c->out = g_io_stream_get_output_stream(G_IO_STREAM (c->conn));

    char *data = "hello world!!!\n";

    printf("I'm here\n");

    g_output_stream_write_async(c->out, data, strlen(data), G_PRIORITY_DEFAULT, NULL, write_done_cb, c);
    g_input_stream_read_async(c->in, c->data, sizeof c->data / sizeof *c->data, G_PRIORITY_DEFAULT, NULL, read_done_cb, c);
}

int
main(int argc, char **argv)
{
    g_type_init();

    struct conn *c = g_malloc0(sizeof *c);
    ctx = g_main_context_new();
    loop = g_main_loop_new(ctx, FALSE);
    g_main_context_push_thread_default(ctx);

    c->client = g_socket_client_new();
    g_socket_client_connect_to_host_async(c->client, "localhost", 1500, NULL, connect_done_cb, c);

    g_main_loop_run(loop);

    g_io_stream_close(G_IO_STREAM(c->conn), NULL, NULL);
    g_object_unref(c->client);
    g_object_unref(c->conn);
    g_main_context_pop_thread_default(ctx);
    g_main_loop_unref(loop);
    g_main_context_unref(ctx);

    return 0;
}

---

希望这对你有帮助

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

#包括
#包括
/*每次客户端尝试连接时，都会调用此函数*/
gboolean
传入的_回调（GSocketService*服务，
GSocketConnection*连接，
GObject*源对象，
gpointer用户（U数据）
{
g_print（“接收到来自客户端的连接！\n”）；
GInputStream*istream=g_io_流_获取_输入_流（g_io_流（连接））；
gchar消息[1024]；
g_输入_流_读取（istream，
消息
1024,
无效的
无效）；
g_print（“消息是：\%s\”\n，消息）；
返回FALSE；
}
int
主（内部argc，字符**argv）
{
/*初始化油嘴滑舌*/
g_type_init（）；
GError*error=NULL；
/*创建新的socketservice*/
GSocketService*service=g_socket_service_new（）；
/*连接到端口*/
g_套接字_侦听器_添加_inet_端口（（GSocketListener*）服务，
1500，/*您的端口在这里*/
无效的
&误差）；
/*别忘了检查错误*/
if（错误！=NULL）
{
g_错误（错误->消息）；
}
/*收听“传入”信号*/
g_信号_连接（服务、，
“传入”，
G_回调（传入_回调），
无效）；
/*启动套接字服务*/
g_插座_服务_启动（服务）；
/*进入主循环*/
g_print（“等待客户！\n”）；
GMainLoop*loop=g_main_loop_new（NULL，FALSE）；
g_主循环运行（循环）；
返回0；
}