libpurple/purple-gio.c

   1 /*
   2  *
   3  * purple
   4  *
   5  * Purple is the legal property of its developers, whose names are too numerous
   6  * to list here.  Please refer to the COPYRIGHT file distributed with this
   7  * source distribution.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  22  */
  23
  24 #include "internal.h"
  25 #include "proxy.h"
  26 #include "purple-gio.h"
  27
  28 typedef struct {
  29         GIOStream *stream;
  30         GInputStream *input;
  31         GOutputStream *output;
  32 } GracefulCloseData;
  33
  34 static gboolean
  35 graceful_close_cb(gpointer user_data)
  36 {
  37         GracefulCloseData *data = user_data;
  38         GError *error = NULL;
  39
  40         if (g_input_stream_has_pending(data->input) ||
  41                         g_output_stream_has_pending(data->output)) {
  42                 /* Has pending operations. Not ready to close yet.
  43                  * Try again later.
  44                  */
  45                 return G_SOURCE_CONTINUE;
  46         }
  47
  48         /* Finally can gracefully close */
  49
  50         /* Close input stream, from wrapper or GIOStream */
  51         if (!g_input_stream_close(data->input, NULL, &error)) {
  52                 purple_debug_warning("gio",
  53                                 "Error closing input stream: %s",
  54                                 error->message);
  55                 g_clear_error(&error);
  56         }
  57
  58         g_clear_object(&data->input);
  59
  60         /* Close output stream, from wrapper or GIOStream */
  61         if (!g_output_stream_close(data->output, NULL, &error)) {
  62                 purple_debug_warning("gio",
  63                                 "Error closing output stream: %s",
  64                                 error->message);
  65                 g_clear_error(&error);
  66         }
  67
  68         g_clear_object(&data->output);
  69
  70         /* Close io stream */
  71         if (!g_io_stream_close(data->stream, NULL, &error)) {
  72                 purple_debug_warning("gio",
  73                                 "Error closing stream: %s",
  74                                 error->message);
  75                 g_clear_error(&error);
  76         }
  77
  78         g_clear_object(&data->stream);
  79
  80         /* Clean up */
  81         g_free(data);
  82         return G_SOURCE_REMOVE;
  83 }
  84
  85 void
  86 purple_gio_graceful_close(GIOStream *stream,
  87                 GInputStream *input, GOutputStream *output)
  88 {
  89         GracefulCloseData *data;
  90
  91         g_return_if_fail(G_IS_IO_STREAM(stream));
  92         g_return_if_fail(input == NULL || G_IS_INPUT_STREAM(input));
  93         g_return_if_fail(output == NULL || G_IS_OUTPUT_STREAM(output));
  94
  95         data = g_new(GracefulCloseData, 1);
  96         data->stream = g_object_ref(stream);
  97
  98         if (input == NULL)
  99                 input = g_io_stream_get_input_stream(stream);
 100         data->input = g_object_ref(input);
 101
 102         if (output == NULL)
 103                 output = g_io_stream_get_output_stream(stream);
 104         data->output = g_object_ref(output);
 105
 106         /* Try gracefully closing the stream synchronously */
 107         if (graceful_close_cb(data) == G_SOURCE_CONTINUE) {
 108                 /* Has pending operations. Do so asynchronously */
 109                 g_idle_add(graceful_close_cb, data);
 110         }
 111 }
 112
 113 GSocketClient *
 114 purple_gio_socket_client_new(PurpleAccount *account, GError **error)
 115 {
 116         GProxyResolver *resolver;
 117         GSocketClient *client;
 118
 119         resolver = purple_proxy_get_proxy_resolver(account, error);
 120
 121         if (resolver == NULL) {
 122                 return NULL;
 123         }
 124
 125         client = g_socket_client_new();
 126         g_socket_client_set_proxy_resolver(client, resolver);
 127         g_object_unref(resolver);
 128
 129         return client;
 130 }
 131