plugins/pacrunner.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
   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 version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <string.h>
  28
  29 #include <gdbus.h>
  30
  31 #define CONNMAN_API_SUBJECT_TO_CHANGE
  32 #include <connman/plugin.h>
  33 #include <connman/notifier.h>
  34 #include <connman/dbus.h>
  35 #include <connman/log.h>
  36 #include <connman/proxy.h>
  37
  38 #define PACRUNNER_SERVICE       "org.pacrunner"
  39 #define PACRUNNER_INTERFACE     "org.pacrunner.Manager"
  40 #define PACRUNNER_PATH          "/org/pacrunner/manager"
  41
  42 #define PACRUNNER_CLIENT_INTERFACE      "org.pacrunner.Client"
  43 #define PACRUNNER_CLIENT_PATH           "/org/pacrunner/client"
  44
  45 #define DBUS_TIMEOUT    5000
  46
  47 struct proxy_data {
  48         struct connman_service *service;
  49         char *url;
  50 };
  51
  52 static DBusConnection *connection;
  53 static dbus_bool_t daemon_running = FALSE;
  54
  55 static struct connman_service *default_service = NULL;
  56 static char *current_config = NULL;
  57
  58 static void create_config_reply(DBusPendingCall *call, void *user_data)
  59 {
  60         DBusMessage *reply = dbus_pending_call_steal_reply(call);
  61         const char *path;
  62
  63         DBG("");
  64
  65         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
  66                 connman_error("Failed to create proxy configuration");
  67                 goto done;
  68         }
  69
  70         if (dbus_message_get_args(reply, NULL, DBUS_TYPE_OBJECT_PATH, &path,
  71                                                 DBUS_TYPE_INVALID) == FALSE)
  72                 goto done;
  73
  74         g_free(current_config);
  75         current_config = g_strdup(path);
  76
  77 done:
  78         dbus_message_unref(reply);
  79 }
  80
  81 static void append_string(DBusMessageIter *iter, void *user_data)
  82 {
  83         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, user_data);
  84 }
  85
  86 static void append_string_list(DBusMessageIter *iter, void *user_data)
  87 {
  88         char **list = user_data;
  89         int i;
  90
  91         for (i = 0; list[i] != NULL; i++)
  92                 dbus_message_iter_append_basic(iter,
  93                                         DBUS_TYPE_STRING, &list[i]);
  94 }
  95
  96 static void create_proxy_configuration(void)
  97 {
  98         DBusMessage *msg;
  99         DBusMessageIter iter, dict;
 100         DBusPendingCall *call;
 101         dbus_bool_t result;
 102         char *interface;
 103         const char *method;
 104         const char *str;
 105         char **str_list;
 106
 107         if (default_service == NULL)
 108                 return;
 109
 110         DBG("");
 111
 112         msg = dbus_message_new_method_call(PACRUNNER_SERVICE, PACRUNNER_PATH,
 113                         PACRUNNER_INTERFACE, "CreateProxyConfiguration");
 114         if (msg == NULL)
 115                 return;
 116
 117         dbus_message_set_auto_start(msg, FALSE);
 118
 119         dbus_message_iter_init_append(msg, &iter);
 120         connman_dbus_dict_open(&iter, &dict);
 121
 122         switch(connman_service_get_proxy_method(default_service)) {
 123         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
 124                 goto done;
 125         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
 126                 method= "direct";
 127                 break;
 128         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
 129                 method = "manual";
 130
 131                 str_list = connman_service_get_proxy_servers(default_service);
 132                 if (str_list == NULL)
 133                         goto done;
 134
 135                 connman_dbus_dict_append_array(&dict, "Servers",
 136                                         DBUS_TYPE_STRING, append_string_list,
 137                                         str_list);
 138                 g_strfreev(str_list);
 139
 140                 str_list = connman_service_get_proxy_excludes(default_service);
 141                 if (str_list == NULL)
 142                         break;
 143
 144                 connman_dbus_dict_append_array(&dict, "Excludes",
 145                                         DBUS_TYPE_STRING, append_string_list,
 146                                         str_list);
 147                 g_strfreev(str_list);
 148
 149                 break;
 150         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
 151                 method = "auto";
 152
 153                 str = connman_service_get_proxy_url(default_service);
 154                 if (str == NULL) {
 155                         str = connman_service_get_proxy_autoconfig(
 156                                                         default_service);
 157                         if (str == NULL)
 158                                 goto done;
 159                 }
 160
 161                 connman_dbus_dict_append_basic(&dict, "URL",
 162                                         DBUS_TYPE_STRING, &str);
 163                 break;
 164         }
 165
 166         connman_dbus_dict_append_basic(&dict, "Method",
 167                                 DBUS_TYPE_STRING, &method);
 168
 169         interface = connman_service_get_interface(default_service);
 170         if (interface != NULL) {
 171                 connman_dbus_dict_append_basic(&dict, "Interface",
 172                                                 DBUS_TYPE_STRING, &interface);
 173                 g_free(interface);
 174         }
 175
 176         str = connman_service_get_domainname(default_service);
 177         if (str != NULL)
 178                 connman_dbus_dict_append_array(&dict, "Domains",
 179                                         DBUS_TYPE_STRING, append_string, &str);
 180
 181         str_list = connman_service_get_nameservers(default_service);
 182         if (str_list != NULL)
 183                 connman_dbus_dict_append_array(&dict, "Nameservers",
 184                                         DBUS_TYPE_STRING, append_string_list,
 185                                         &str_list);
 186
 187         connman_dbus_dict_close(&iter, &dict);
 188
 189         result = dbus_connection_send_with_reply(connection, msg,
 190                                                         &call, DBUS_TIMEOUT);
 191
 192         if (result == FALSE || call == NULL)
 193                 goto done;
 194
 195         dbus_pending_call_set_notify(call, create_config_reply, NULL, NULL);
 196
 197         dbus_pending_call_unref(call);
 198
 199 done:
 200         dbus_message_unref(msg);
 201 }
 202
 203 static void destroy_config_reply(DBusPendingCall *call, void *user_data)
 204 {
 205         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 206
 207         DBG("");
 208
 209         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
 210                 connman_error("Failed to destoy proxy configuration");
 211
 212         dbus_message_unref(reply);
 213 }
 214
 215 static void destroy_proxy_configuration(void)
 216 {
 217         DBusMessage *msg;
 218         DBusPendingCall *call;
 219         dbus_bool_t result;
 220
 221         if (current_config == NULL)
 222                 return;
 223
 224         DBG("");
 225
 226         msg = dbus_message_new_method_call(PACRUNNER_SERVICE, PACRUNNER_PATH,
 227                         PACRUNNER_INTERFACE, "DestroyProxyConfiguration");
 228         if (msg == NULL)
 229                 return;
 230
 231         dbus_message_set_auto_start(msg, FALSE);
 232
 233         dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH, &current_config,
 234                                                         DBUS_TYPE_INVALID);
 235
 236         result = dbus_connection_send_with_reply(connection, msg,
 237                                                         &call, DBUS_TIMEOUT);
 238
 239         dbus_message_unref(msg);
 240
 241         if (result == FALSE || call == NULL)
 242                 return;
 243
 244         dbus_pending_call_set_notify(call, destroy_config_reply, NULL, NULL);
 245
 246         dbus_pending_call_unref(call);
 247
 248         g_free(current_config);
 249         current_config = NULL;
 250 }
 251
 252 static void default_service_changed(struct connman_service *service)
 253 {
 254         DBG("service %p", service);
 255
 256         if (service == default_service)
 257                 return;
 258
 259         default_service = service;
 260
 261         if (daemon_running == FALSE)
 262                 return;
 263
 264         destroy_proxy_configuration();
 265
 266         create_proxy_configuration();
 267 }
 268
 269 static void proxy_changed(struct connman_service *service)
 270 {
 271         DBG("service %p", service);
 272
 273         if (service != default_service)
 274                 return;
 275
 276         if (daemon_running == FALSE)
 277                 return;
 278
 279         destroy_proxy_configuration();
 280
 281         create_proxy_configuration();
 282 }
 283
 284 static struct connman_notifier pacrunner_notifier = {
 285         .name                   = "pacrunner",
 286         .default_changed        = default_service_changed,
 287         .proxy_changed          = proxy_changed,
 288 };
 289
 290 static void pacrunner_connect(DBusConnection *conn, void *user_data)
 291 {
 292         DBG("");
 293
 294         daemon_running = TRUE;
 295
 296         create_proxy_configuration();
 297 }
 298
 299 static void pacrunner_disconnect(DBusConnection *conn, void *user_data)
 300 {
 301         DBG("");
 302
 303         daemon_running = FALSE;
 304
 305         g_free(current_config);
 306         current_config = NULL;
 307 }
 308
 309 static char * parse_url(const char *url)
 310 {
 311         char *scheme, *host, *path, *host_ret;
 312
 313         scheme = g_strdup(url);
 314         if (scheme == NULL)
 315                 return NULL;
 316
 317         host = strstr(scheme, "://");
 318         if (host != NULL) {
 319                 *host = '\0';
 320                 host += 3;
 321         } else
 322                 host = scheme;
 323
 324         path = strchr(host, '/');
 325         if (path != NULL)
 326                 *(path++) = '\0';
 327
 328         host_ret = g_strdup(host);
 329
 330         g_free(scheme);
 331
 332         return host_ret;
 333 }
 334
 335 static void request_lookup_reply(DBusPendingCall *call, void *user_data)
 336 {
 337         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 338         struct proxy_data *data = user_data;
 339         const char *proxy;
 340
 341         DBG("");
 342
 343         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 344                 connman_error("Failed to find URL:%s", data->url);
 345                 proxy = NULL;
 346                 goto done;
 347         }
 348
 349         if (dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &proxy,
 350                                                 DBUS_TYPE_INVALID) == FALSE)
 351                 proxy = NULL;
 352
 353 done:
 354         connman_proxy_driver_lookup_notify(data->service, data->url, proxy);
 355
 356         connman_service_unref(data->service);
 357
 358         g_free(data->url);
 359         g_free(data);
 360
 361         dbus_message_unref(reply);
 362 }
 363
 364 static int request_lookup(struct connman_service *service, const char *url)
 365 {
 366         DBusMessage *msg;
 367         DBusPendingCall *call;
 368         dbus_bool_t result;
 369         char *host;
 370         struct proxy_data *data;
 371
 372         DBG("");
 373
 374         if (daemon_running == FALSE)
 375                 return -EINVAL;
 376
 377         msg = dbus_message_new_method_call(PACRUNNER_SERVICE,
 378                                                 PACRUNNER_CLIENT_PATH,
 379                                                 PACRUNNER_CLIENT_INTERFACE,
 380                                                 "FindProxyForURL");
 381         if (msg == NULL)
 382                 return -1;
 383
 384         host = parse_url(url);
 385         if (host == NULL) {
 386                 dbus_message_unref(msg);
 387                 return -EINVAL;
 388         }
 389
 390         data = g_try_new0(struct proxy_data, 1);
 391         if (data == NULL) {
 392                 dbus_message_unref(msg);
 393                 g_free(host);
 394                 return -ENOMEM;
 395         }
 396
 397         data->url = g_strdup(url);
 398         data->service = connman_service_ref(service);
 399
 400         dbus_message_set_auto_start(msg, FALSE);
 401
 402         dbus_message_append_args(msg, DBUS_TYPE_STRING, &url,
 403                                         DBUS_TYPE_STRING, &host,
 404                                         DBUS_TYPE_INVALID);
 405
 406         result = dbus_connection_send_with_reply(connection, msg,
 407                                                         &call, DBUS_TIMEOUT);
 408
 409         dbus_message_unref(msg);
 410
 411         if (result == FALSE || call == NULL) {
 412                 g_free(host);
 413                 g_free(data->url);
 414                 g_free(data);
 415                 return -EINVAL;
 416         }
 417
 418         dbus_pending_call_set_notify(call, request_lookup_reply,
 419                                                         data, NULL);
 420
 421         dbus_pending_call_unref(call);
 422         g_free(host);
 423
 424         return 0;
 425 }
 426
 427 static void cancel_lookup(struct connman_service *service, const char *url)
 428 {
 429         DBG("");
 430 }
 431
 432 static struct connman_proxy_driver pacrunner_proxy = {
 433         .name           = "pacrunnerproxy",
 434         .priority       = CONNMAN_PROXY_PRIORITY_HIGH,
 435         .request_lookup = request_lookup,
 436         .cancel_lookup  = cancel_lookup,
 437 };
 438
 439 static guint pacrunner_watch;
 440
 441 static int pacrunner_init(void)
 442 {
 443         connection = connman_dbus_get_connection();
 444         if (connection == NULL)
 445                 return -EIO;
 446
 447         pacrunner_watch = g_dbus_add_service_watch(connection,
 448                                         PACRUNNER_SERVICE, pacrunner_connect,
 449                                         pacrunner_disconnect, NULL, NULL);
 450         if (pacrunner_watch == 0) {
 451                 dbus_connection_unref(connection);
 452                 return -EIO;
 453         }
 454
 455         connman_notifier_register(&pacrunner_notifier);
 456
 457         connman_proxy_driver_register(&pacrunner_proxy);
 458
 459         return 0;
 460 }
 461
 462 static void pacrunner_exit(void)
 463 {
 464         connman_proxy_driver_unregister(&pacrunner_proxy);
 465
 466         connman_notifier_unregister(&pacrunner_notifier);
 467
 468         g_dbus_remove_watch(connection, pacrunner_watch);
 469
 470         destroy_proxy_configuration();
 471
 472         dbus_connection_unref(connection);
 473 }
 474
 475 CONNMAN_PLUGIN_DEFINE(pacrunner, "PAC runner proxy plugin", VERSION,
 476                 CONNMAN_PLUGIN_PRIORITY_DEFAULT, pacrunner_init, pacrunner_exit)