src/proxy.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 <glib.h>
  27
  28 #include "connman.h"
  29
  30 static unsigned int next_lookup_token = 1;
  31
  32 static GSList *driver_list = NULL;
  33 static GSList *lookup_list = NULL;
  34
  35 struct proxy_lookup {
  36         unsigned int token;
  37         connman_proxy_lookup_cb cb;
  38         void *user_data;
  39         struct connman_service *service;
  40         char *url;
  41         guint watch;
  42         struct connman_proxy_driver *proxy;
  43 };
  44
  45 static void remove_lookup(struct proxy_lookup *lookup)
  46 {
  47         lookup_list = g_slist_remove(lookup_list, lookup);
  48
  49         connman_service_unref(lookup->service);
  50         g_free(lookup->url);
  51         g_free(lookup);
  52 }
  53
  54 static void remove_lookups(GSList *lookups)
  55 {
  56         GSList *list;
  57
  58         for (list = lookups; list; list = list->next) {
  59                 struct proxy_lookup *lookup = list->data;
  60
  61                 remove_lookup(lookup);
  62         }
  63
  64         g_slist_free(lookups);
  65 }
  66
  67 static gboolean lookup_callback(gpointer user_data)
  68 {
  69         struct proxy_lookup *lookup = user_data;
  70         GSList *list;
  71
  72         if (lookup == NULL)
  73                 return FALSE;
  74
  75         lookup->watch = 0;
  76
  77         for (list = driver_list; list; list = list->next) {
  78                 struct connman_proxy_driver *proxy = list->data;
  79
  80                 if (proxy->request_lookup == NULL)
  81                         continue;
  82
  83                 lookup->proxy = proxy;
  84                 break;
  85         }
  86
  87         if (lookup->proxy == NULL ||
  88                 lookup->proxy->request_lookup(lookup->service,
  89                                                 lookup->url) < 0) {
  90
  91                 if (lookup->cb)
  92                         lookup->cb(NULL, lookup->user_data);
  93
  94                 remove_lookup(lookup);
  95         }
  96
  97         return FALSE;
  98 }
  99
 100 unsigned int connman_proxy_lookup(const char *interface, const char *url,
 101                                         struct connman_service *service,
 102                                         connman_proxy_lookup_cb cb,
 103                                         void *user_data)
 104 {
 105         struct proxy_lookup *lookup;
 106
 107         DBG("interface %s url %s", interface, url);
 108
 109         if (interface == NULL)
 110                 return 0;
 111
 112         lookup = g_try_new0(struct proxy_lookup, 1);
 113         if (lookup == NULL)
 114                 return 0;
 115
 116         lookup->token = next_lookup_token++;
 117
 118         lookup->cb = cb;
 119         lookup->user_data = user_data;
 120         lookup->url = g_strdup(url);
 121         lookup->service = connman_service_ref(service);
 122
 123         lookup->watch = g_timeout_add_seconds(0, lookup_callback, lookup);
 124         if (lookup->watch == 0) {
 125                 g_free(lookup->url);
 126                 g_free(lookup);
 127                 return 0;
 128         }
 129
 130         DBG("token %u", lookup->token);
 131         lookup_list = g_slist_append(lookup_list, lookup);
 132
 133         return lookup->token;
 134 }
 135
 136 void connman_proxy_lookup_cancel(unsigned int token)
 137 {
 138         GSList *list;
 139         struct proxy_lookup *lookup = NULL;
 140
 141         DBG("token %u", token);
 142
 143         for (list = lookup_list; list; list = list->next) {
 144                 lookup = list->data;
 145
 146                 if (lookup->token == token)
 147                         break;
 148         }
 149
 150         if (lookup != NULL) {
 151                 if (lookup->watch > 0) {
 152                         g_source_remove(lookup->watch);
 153                         lookup->watch = 0;
 154                 }
 155
 156                 if (lookup->proxy != NULL &&
 157                                         lookup->proxy->cancel_lookup != NULL)
 158                         lookup->proxy->cancel_lookup(lookup->service,
 159                                                                 lookup->url);
 160
 161                 remove_lookup(lookup);
 162         }
 163 }
 164
 165 void connman_proxy_driver_lookup_notify(struct connman_service *service,
 166                                         const char *url, const char *result)
 167 {
 168         GSList *list, *matches = NULL;
 169
 170         DBG("service %p url %s result %s", service, url, result);
 171
 172         for (list = lookup_list; list; list = list->next) {
 173                 struct proxy_lookup *lookup = list->data;
 174
 175                 if (service != lookup->service)
 176                         continue;
 177
 178                 if (g_strcmp0(lookup->url, url) == 0) {
 179                         if (lookup->cb)
 180                                 lookup->cb(result, lookup->user_data);
 181
 182                         matches = g_slist_append(matches, lookup);
 183                 }
 184         }
 185
 186         if (matches != NULL)
 187                 remove_lookups(matches);
 188 }
 189
 190 static gint compare_priority(gconstpointer a, gconstpointer b)
 191 {
 192         const struct connman_proxy_driver *driver1 = a;
 193         const struct connman_proxy_driver *driver2 = b;
 194
 195         return driver2->priority - driver1->priority;
 196 }
 197
 198 /**
 199  * connman_proxy_driver_register:
 200  * @driver: Proxy driver definition
 201  *
 202  * Register a new proxy driver
 203  *
 204  * Returns: %0 on success
 205  */
 206 int connman_proxy_driver_register(struct connman_proxy_driver *driver)
 207 {
 208         DBG("driver %p name %s", driver, driver->name);
 209
 210         driver_list = g_slist_insert_sorted(driver_list, driver,
 211                                                         compare_priority);
 212
 213         return 0;
 214 }
 215
 216 /**
 217  * connman_proxy_driver_unregister:
 218  * @driver: Proxy driver definition
 219  *
 220  * Remove a previously registered proxy driver
 221  */
 222 void connman_proxy_driver_unregister(struct connman_proxy_driver *driver)
 223 {
 224         GSList *list;
 225
 226         DBG("driver %p name %s", driver, driver->name);
 227
 228         driver_list = g_slist_remove(driver_list, driver);
 229
 230         for (list = lookup_list; list; list = list->next) {
 231                 struct proxy_lookup *lookup = list->data;
 232
 233                 if (lookup->proxy == driver)
 234                         lookup->proxy = NULL;
 235         }
 236
 237 }
 238
 239 int __connman_proxy_init(void)
 240 {
 241         DBG("");
 242
 243         return 0;
 244 }
 245
 246 void __connman_proxy_cleanup(void)
 247 {
 248         DBG("");
 249
 250         remove_lookups(lookup_list);
 251 }