libpurple/purple-socket.c

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
  20  */
  21
  22 #include "purple-socket.h"
  23
  24 #include "internal.h"
  25
  26 #include "debug.h"
  27 #include "proxy.h"
  28 #include "sslconn.h"
  29
  30 typedef enum {
  31         PURPLE_SOCKET_STATE_DISCONNECTED = 0,
  32         PURPLE_SOCKET_STATE_CONNECTING,
  33         PURPLE_SOCKET_STATE_CONNECTED,
  34         PURPLE_SOCKET_STATE_ERROR
  35 } PurpleSocketState;
  36
  37 struct _PurpleSocket
  38 {
  39         PurpleConnection *gc;
  40         gchar *host;
  41         int port;
  42         gboolean is_tls;
  43         GHashTable *data;
  44
  45         PurpleSocketState state;
  46
  47         PurpleSslConnection *tls_connection;
  48         PurpleProxyConnectData *raw_connection;
  49         int fd;
  50         guint inpa;
  51
  52         PurpleSocketConnectCb cb;
  53         gpointer cb_data;
  54 };
  55
  56 static GHashTable *handles = NULL;
  57
  58 static void
  59 handle_add(PurpleSocket *ps)
  60 {
  61         PurpleConnection *gc = ps->gc;
  62         GSList *l;
  63
  64         l = g_hash_table_lookup(handles, gc);
  65         l = g_slist_prepend(l, ps);
  66         g_hash_table_insert(handles, gc, l);
  67 }
  68
  69 static void
  70 handle_remove(PurpleSocket *ps)
  71 {
  72         PurpleConnection *gc = ps->gc;
  73         GSList *l;
  74
  75         l = g_hash_table_lookup(handles, gc);
  76         l = g_slist_remove(l, ps);
  77         g_hash_table_insert(handles, gc, l);
  78 }
  79
  80 void
  81 _purple_socket_init(void)
  82 {
  83         handles = g_hash_table_new(g_direct_hash, g_direct_equal);
  84 }
  85
  86 void
  87 _purple_socket_uninit(void)
  88 {
  89         g_hash_table_destroy(handles);
  90         handles = NULL;
  91 }
  92
  93 PurpleSocket *
  94 purple_socket_new(PurpleConnection *gc)
  95 {
  96         PurpleSocket *ps = g_new0(PurpleSocket, 1);
  97
  98         ps->gc = gc;
  99         ps->fd = -1;
 100         ps->port = -1;
 101         ps->data = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 102
 103         handle_add(ps);
 104
 105         return ps;
 106 }
 107
 108 PurpleConnection *
 109 purple_socket_get_connection(PurpleSocket *ps)
 110 {
 111         g_return_val_if_fail(ps != NULL, NULL);
 112
 113         return ps->gc;
 114 }
 115
 116 static gboolean
 117 purple_socket_check_state(PurpleSocket *ps, PurpleSocketState wanted_state)
 118 {
 119         g_return_val_if_fail(ps != NULL, FALSE);
 120
 121         if (ps->state == wanted_state)
 122                 return TRUE;
 123
 124         purple_debug_error("socket", "invalid state: %d (should be: %d)",
 125                 ps->state, wanted_state);
 126         ps->state = PURPLE_SOCKET_STATE_ERROR;
 127         return FALSE;
 128 }
 129
 130 void
 131 purple_socket_set_tls(PurpleSocket *ps, gboolean is_tls)
 132 {
 133         g_return_if_fail(ps != NULL);
 134
 135         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_DISCONNECTED))
 136                 return;
 137
 138         ps->is_tls = is_tls;
 139 }
 140
 141 void
 142 purple_socket_set_host(PurpleSocket *ps, const gchar *host)
 143 {
 144         g_return_if_fail(ps != NULL);
 145
 146         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_DISCONNECTED))
 147                 return;
 148
 149         g_free(ps->host);
 150         ps->host = g_strdup(host);
 151 }
 152
 153 void
 154 purple_socket_set_port(PurpleSocket *ps, int port)
 155 {
 156         g_return_if_fail(ps != NULL);
 157         g_return_if_fail(port >= 0);
 158         g_return_if_fail(port <= 65535);
 159
 160         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_DISCONNECTED))
 161                 return;
 162
 163         ps->port = port;
 164 }
 165
 166 static void
 167 _purple_socket_connected_raw(gpointer _ps, gint fd, const gchar *error_message)
 168 {
 169         PurpleSocket *ps = _ps;
 170
 171         ps->raw_connection = NULL;
 172
 173         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_CONNECTING)) {
 174                 if (fd > 0)
 175                         close(fd);
 176                 ps->cb(ps, _("Invalid socket state"), ps->cb_data);
 177                 return;
 178         }
 179
 180         if (fd <= 0 || error_message != NULL) {
 181                 if (error_message == NULL)
 182                         error_message = _("Unknown error");
 183                 ps->fd = -1;
 184                 ps->state = PURPLE_SOCKET_STATE_ERROR;
 185                 ps->cb(ps, error_message, ps->cb_data);
 186                 return;
 187         }
 188
 189         ps->state = PURPLE_SOCKET_STATE_CONNECTED;
 190         ps->fd = fd;
 191         ps->cb(ps, NULL, ps->cb_data);
 192 }
 193
 194 static void
 195 _purple_socket_connected_tls(gpointer _ps, PurpleSslConnection *tls_connection,
 196         PurpleInputCondition cond)
 197 {
 198         PurpleSocket *ps = _ps;
 199
 200         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_CONNECTING)) {
 201                 purple_ssl_close(tls_connection);
 202                 ps->tls_connection = NULL;
 203                 ps->cb(ps, _("Invalid socket state"), ps->cb_data);
 204                 return;
 205         }
 206
 207         if (ps->tls_connection->fd <= 0) {
 208                 ps->state = PURPLE_SOCKET_STATE_ERROR;
 209                 purple_ssl_close(tls_connection);
 210                 ps->tls_connection = NULL;
 211                 ps->cb(ps, _("Invalid file descriptor"), ps->cb_data);
 212                 return;
 213         }
 214
 215         ps->state = PURPLE_SOCKET_STATE_CONNECTED;
 216         ps->fd = ps->tls_connection->fd;
 217         ps->cb(ps, NULL, ps->cb_data);
 218 }
 219
 220 static void
 221 _purple_socket_connected_tls_error(PurpleSslConnection *ssl_connection,
 222         PurpleSslErrorType error, gpointer _ps)
 223 {
 224         PurpleSocket *ps = _ps;
 225
 226         ps->state = PURPLE_SOCKET_STATE_ERROR;
 227         ps->tls_connection = NULL;
 228         ps->cb(ps, purple_ssl_strerror(error), ps->cb_data);
 229 }
 230
 231 gboolean
 232 purple_socket_connect(PurpleSocket *ps, PurpleSocketConnectCb cb,
 233         gpointer user_data)
 234 {
 235         PurpleAccount *account = NULL;
 236
 237         g_return_val_if_fail(ps != NULL, FALSE);
 238
 239         if (ps->gc && purple_connection_is_disconnecting(ps->gc)) {
 240                 purple_debug_error("socket", "connection is being destroyed");
 241                 ps->state = PURPLE_SOCKET_STATE_ERROR;
 242                 return FALSE;
 243         }
 244
 245         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_DISCONNECTED))
 246                 return FALSE;
 247         ps->state = PURPLE_SOCKET_STATE_CONNECTING;
 248
 249         if (ps->host == NULL || ps->port < 0) {
 250                 purple_debug_error("socket", "Host or port is not specified");
 251                 ps->state = PURPLE_SOCKET_STATE_ERROR;
 252                 return FALSE;
 253         }
 254
 255         if (ps->gc != NULL)
 256                 account = purple_connection_get_account(ps->gc);
 257
 258         ps->cb = cb;
 259         ps->cb_data = user_data;
 260
 261         if (ps->is_tls) {
 262                 ps->tls_connection = purple_ssl_connect(account, ps->host,
 263                         ps->port, _purple_socket_connected_tls,
 264                         _purple_socket_connected_tls_error, ps);
 265         } else {
 266                 ps->raw_connection = purple_proxy_connect(ps->gc, account,
 267                         ps->host, ps->port, _purple_socket_connected_raw, ps);
 268         }
 269
 270         if (ps->tls_connection == NULL &&
 271                 ps->raw_connection == NULL)
 272         {
 273                 ps->state = PURPLE_SOCKET_STATE_ERROR;
 274                 return FALSE;
 275         }
 276
 277         return TRUE;
 278 }
 279
 280 gssize
 281 purple_socket_read(PurpleSocket *ps, guchar *buf, size_t len)
 282 {
 283         g_return_val_if_fail(ps != NULL, -1);
 284         g_return_val_if_fail(buf != NULL, -1);
 285
 286         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_CONNECTED))
 287                 return -1;
 288
 289         if (ps->is_tls)
 290                 return purple_ssl_read(ps->tls_connection, buf, len);
 291         else
 292                 return read(ps->fd, buf, len);
 293 }
 294
 295 gssize
 296 purple_socket_write(PurpleSocket *ps, const guchar *buf, size_t len)
 297 {
 298         g_return_val_if_fail(ps != NULL, -1);
 299         g_return_val_if_fail(buf != NULL, -1);
 300
 301         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_CONNECTED))
 302                 return -1;
 303
 304         if (ps->is_tls)
 305                 return purple_ssl_write(ps->tls_connection, buf, len);
 306         else
 307                 return write(ps->fd, buf, len);
 308 }
 309
 310 void
 311 purple_socket_watch(PurpleSocket *ps, PurpleInputCondition cond,
 312         PurpleInputFunction func, gpointer user_data)
 313 {
 314         g_return_if_fail(ps != NULL);
 315
 316         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_CONNECTED))
 317                 return;
 318
 319         if (ps->inpa > 0)
 320                 purple_input_remove(ps->inpa);
 321         ps->inpa = 0;
 322
 323         g_return_if_fail(ps->fd > 0);
 324
 325         if (func != NULL)
 326                 ps->inpa = purple_input_add(ps->fd, cond, func, user_data);
 327 }
 328
 329 int
 330 purple_socket_get_fd(PurpleSocket *ps)
 331 {
 332         g_return_val_if_fail(ps != NULL, -1);
 333
 334         if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_CONNECTED))
 335                 return -1;
 336
 337         g_return_val_if_fail(ps->fd > 0, -1);
 338
 339         return ps->fd;
 340 }
 341
 342 void
 343 purple_socket_set_data(PurpleSocket *ps, const gchar *key, gpointer data)
 344 {
 345         g_return_if_fail(ps != NULL);
 346         g_return_if_fail(key != NULL);
 347
 348         if (data == NULL)
 349                 g_hash_table_remove(ps->data, key);
 350         else
 351                 g_hash_table_insert(ps->data, g_strdup(key), data);
 352 }
 353
 354 gpointer
 355 purple_socket_get_data(PurpleSocket *ps, const gchar *key)
 356 {
 357         g_return_val_if_fail(ps != NULL, NULL);
 358         g_return_val_if_fail(key != NULL, NULL);
 359
 360         return g_hash_table_lookup(ps->data, key);
 361 }
 362
 363 static void
 364 purple_socket_cancel(PurpleSocket *ps)
 365 {
 366         if (ps->inpa > 0)
 367                 purple_input_remove(ps->inpa);
 368         ps->inpa = 0;
 369
 370         if (ps->tls_connection != NULL) {
 371                 purple_ssl_close(ps->tls_connection);
 372                 ps->fd = -1;
 373         }
 374         ps->tls_connection = NULL;
 375
 376         if (ps->raw_connection != NULL)
 377                 purple_proxy_connect_cancel(ps->raw_connection);
 378         ps->raw_connection = NULL;
 379
 380         if (ps->fd > 0)
 381                 close(ps->fd);
 382         ps->fd = 0;
 383 }
 384
 385 void
 386 purple_socket_destroy(PurpleSocket *ps)
 387 {
 388         if (ps == NULL)
 389                 return;
 390
 391         handle_remove(ps);
 392
 393         purple_socket_cancel(ps);
 394
 395         g_free(ps->host);
 396         g_hash_table_destroy(ps->data);
 397         g_free(ps);
 398 }
 399
 400 void
 401 _purple_socket_cancel_with_connection(PurpleConnection *gc)
 402 {
 403         GSList *it;
 404
 405         it = g_hash_table_lookup(handles, gc);
 406         for (; it; it = g_slist_next(it)) {
 407                 PurpleSocket *ps = it->data;
 408                 purple_socket_cancel(ps);
 409         }
 410 }