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 #include "tls-certificate.h"
  28
  29 typedef struct {
  30         GIOStream *stream;
  31         GInputStream *input;
  32         GOutputStream *output;
  33 } GracefulCloseData;
  34
  35 static gboolean
  36 graceful_close_cb(gpointer user_data)
  37 {
  38         GracefulCloseData *data = user_data;
  39         GError *error = NULL;
  40
  41         if (g_input_stream_has_pending(data->input) ||
  42                         g_output_stream_has_pending(data->output)) {
  43                 /* Has pending operations. Not ready to close yet.
  44                  * Try again later.
  45                  */
  46                 return G_SOURCE_CONTINUE;
  47         }
  48
  49         /* Finally can gracefully close */
  50
  51         /* Close wrapper input stream, if any */
  52         if (data->input != NULL &&
  53                         !g_input_stream_close(data->input, NULL, &error)) {
  54                 purple_debug_warning("gio",
  55                                 "Error closing input stream: %s",
  56                                 error->message);
  57                 g_clear_error(&error);
  58         }
  59
  60         g_clear_object(&data->input);
  61
  62         /* Close wrapper output stream, if any */
  63         if (data->output != NULL &&
  64                         !g_output_stream_close(data->output, NULL, &error)) {
  65                 purple_debug_warning("gio",
  66                                 "Error closing output stream: %s",
  67                                 error->message);
  68                 g_clear_error(&error);
  69         }
  70
  71         g_clear_object(&data->output);
  72
  73         /* Close io stream */
  74         if (!g_io_stream_close(data->stream, NULL, &error)) {
  75                 purple_debug_warning("gio",
  76                                 "Error closing stream: %s",
  77                                 error->message);
  78                 g_clear_error(&error);
  79         }
  80
  81         g_clear_object(&data->stream);
  82
  83         /* Clean up */
  84         g_free(data);
  85         return G_SOURCE_REMOVE;
  86 }
  87
  88 void
  89 purple_gio_graceful_close(GIOStream *stream,
  90                 GInputStream *input, GOutputStream *output)
  91 {
  92         GracefulCloseData *data;
  93
  94         g_return_if_fail(G_IS_IO_STREAM(stream));
  95         g_return_if_fail(input == NULL || G_IS_INPUT_STREAM(input));
  96         g_return_if_fail(output == NULL || G_IS_OUTPUT_STREAM(output));
  97
  98         data = g_new(GracefulCloseData, 1);
  99         data->stream = g_object_ref(stream);
 100         data->input = g_object_ref(input);
 101         data->output = g_object_ref(output);
 102
 103         /* Try gracefully closing the stream synchronously */
 104         if (graceful_close_cb(data) == G_SOURCE_CONTINUE) {
 105                 /* Has pending operations. Do so asynchronously */
 106                 g_idle_add(graceful_close_cb, data);
 107         }
 108 }
 109
 110 GSocketClient *
 111 purple_gio_socket_client_new(PurpleAccount *account, GError **error)
 112 {
 113         GProxyResolver *resolver;
 114         GSocketClient *client;
 115
 116         resolver = purple_proxy_get_proxy_resolver(account, error);
 117
 118         if (resolver == NULL) {
 119                 return NULL;
 120         }
 121
 122         client = g_socket_client_new();
 123         g_socket_client_set_proxy_resolver(client, resolver);
 124         g_object_unref(resolver);
 125
 126         /* Attach purple's tls certificate handler in case tls is used */
 127         purple_tls_certificate_attach_to_socket_client(client);
 128
 129         return client;
 130 }
 131