handler_avahi.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2
   3 /* Cherokee
   4  *
   5  * Authors:
   6  *      Alvaro Lopez Ortega <alvaro@alobbs.com>
   7  *      Stefan de Konink <stefan@konink.de>
   8  *
   9  * Copyright (C) 2001-2008 Alvaro Lopez Ortega
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of version 2 of the GNU General Public
  13  * License as published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  23  * USA
  24  */
  25
  26 #include "handler_avahi.h"
  27 #include <cherokee/cherokee.h>
  28
  29 #include <avahi-client/client.h>
  30 #include <avahi-client/lookup.h>
  31
  32 #include <avahi-common/malloc.h>
  33 #include <avahi-common/error.h>
  34
  35 /* Plug-in initialization
  36  *
  37  * In this function you can use any of these:
  38  * http_delete | http_get | http_post | http_put
  39  *
  40  * For a full list: cherokee_http_method_t
  41  *
  42  * It is what your handler to be implements.
  43  *
  44  */
  45 PLUGIN_INFO_HANDLER_EASIEST_INIT (avahi, http_get);
  46
  47
  48 /* Methods implementation
  49  */
  50
  51 ret_t
  52 cherokee_handler_avahi_props_free (cherokee_handler_avahi_props_t *props)
  53 {
  54     if (props->threaded_poll)
  55        avahi_threaded_poll_stop(props->threaded_poll);
  56
  57     if (props->sb)
  58         avahi_service_browser_free(props->sb);
  59
  60     if (props->client)
  61        avahi_client_free(props->client);
  62
  63     if (props->threaded_poll)
  64         avahi_threaded_poll_free(props->threaded_poll);
  65
  66     cherokee_buffer_mrproper(&props->service_type);
  67
  68     cherokee_avl_r_mrproper (&props->entries, (cherokee_func_free_t) cherokee_buffer_mrproper);
  69
  70         return cherokee_module_props_free_base (MODULE_PROPS(props));
  71 }
  72
  73
  74 ret_t
  75 cherokee_handler_avahi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
  76 {
  77         cherokee_list_t                      *i;
  78         cherokee_handler_avahi_props_t *props;
  79     int error;
  80
  81         if (*_props == NULL) {
  82                 CHEROKEE_NEW_STRUCT (n, handler_avahi_props);
  83
  84                 cherokee_module_props_init_base (MODULE_PROPS(n),
  85                                                  MODULE_PROPS_FREE(cherokee_handler_avahi_props_free));
  86
  87         /* Look at handler_avahi.h
  88          * This is an avahi of configuration.
  89          */
  90         cherokee_buffer_init (&n->service_type);
  91
  92                 *_props = MODULE_PROPS(n);
  93         }
  94
  95         props = PROP_AVAHI(*_props);
  96
  97         cherokee_config_node_foreach (i, conf) {
  98                 cherokee_config_node_t *subconf = CONFIG_NODE(i);
  99
 100         if (equal_buf_str (&subconf->key, "service_type")) {
 101             cherokee_buffer_add_buffer (&props->service_type, &subconf->val);
 102                 }
 103         }
 104
 105     /* If the configuration for avahi was not set, we should not continue */
 106     if (props->service_type.len == 0) {
 107         return ret_error;
 108     }
 109
 110     props->client = NULL;
 111     props->sb = NULL;
 112     props->threaded_poll = NULL;
 113
 114     cherokee_avl_r_init(&props->entries);
 115
 116     if (!(props->threaded_poll = avahi_threaded_poll_new())) {
 117         return ret_error;
 118     }
 119
 120     client_callback(props->client, AVAHI_CLIENT_FAILURE, props); /* create the avahi client in a creative way */
 121
 122     /* Finally, start the event loop thread */
 123     if (avahi_threaded_poll_start(props->threaded_poll) < 0) {
 124         return ret_error;
 125     }
 126
 127         return ret_ok;
 128 }
 129
 130 ret_t
 131 cherokee_handler_avahi_new  (cherokee_handler_t **hdl, cherokee_connection_t *cnt, cherokee_module_props_t *props)
 132 {
 133         ret_t ret;
 134
 135         CHEROKEE_NEW_STRUCT (n, handler_avahi);
 136
 137         /* Init the base class object
 138          */
 139         cherokee_handler_init_base(HANDLER(n), cnt, HANDLER_PROPS(props), PLUGIN_INFO_HANDLER_PTR(avahi));
 140
 141         MODULE(n)->init         = (handler_func_init_t) cherokee_handler_avahi_init;
 142         MODULE(n)->free         = (module_func_free_t) cherokee_handler_avahi_free;
 143         HANDLER(n)->step        = (handler_func_step_t) cherokee_handler_avahi_step;
 144         HANDLER(n)->add_headers = (handler_func_add_headers_t) cherokee_handler_avahi_add_headers;
 145
 146         HANDLER(n)->support = hsupport_length | hsupport_range;
 147
 148         /* Init
 149          */
 150         ret = cherokee_buffer_init (&n->buffer);
 151         if (unlikely(ret != ret_ok))
 152                 return ret;
 153
 154         ret = cherokee_buffer_ensure_size (&n->buffer, 4*1024);
 155         if (unlikely(ret != ret_ok))
 156                 return ret;
 157
 158         *hdl = HANDLER(n);
 159
 160         return ret_ok;
 161 }
 162
 163
 164 ret_t
 165 cherokee_handler_avahi_free (cherokee_handler_avahi_t *hdl)
 166 {
 167         cherokee_buffer_mrproper (&hdl->buffer);
 168
 169         return ret_ok;
 170 }
 171
 172 static ret_t
 173 while_func_entries (cherokee_buffer_t *key, void *value, void *param) {
 174     cherokee_buffer_t *buf = (cherokee_buffer_t *)param;
 175     cherokee_buffer_t *buf2 = (cherokee_buffer_t *)value;
 176
 177     cherokee_buffer_add_buffer (buf, key);
 178     cherokee_buffer_add_str (buf, " - ");
 179     cherokee_buffer_add_buffer (buf, buf2);
 180 //    cherokee_buffer_add (buf, value, strlen(value));
 181     cherokee_buffer_add_str (buf, "\n");
 182
 183     return ret_ok;
 184 }
 185
 186 static void
 187 avahi_build_page (cherokee_handler_avahi_t *hdl)
 188 {
 189     ret_t              ret;
 190     cherokee_buffer_t *buf;
 191
 192     /* Init
 193      */
 194     buf = &hdl->buffer;
 195
 196     /* Useful output
 197      */
 198
 199     /* First, block the event loop */
 200 //    avahi_threaded_poll_lock(HDL_AVAHI_PROPS(hdl)->threaded_poll);
 201
 202     /* Than, do your stuff */
 203     cherokee_avl_r_while (&HDL_AVAHI_PROPS(hdl)->entries, (cherokee_avl_while_func_t) while_func_entries, (void *) buf, NULL, NULL);
 204
 205     /* Finally, unblock the event loop */
 206 //    avahi_threaded_poll_unlock(HDL_AVAHI_PROPS(hdl)->threaded_poll);
 207 }
 208
 209 ret_t
 210 cherokee_handler_avahi_init (cherokee_handler_avahi_t *hdl)
 211 {
 212         ret_t   ret;
 213         void   *param;
 214         cint_t  web_interface = 1;
 215
 216         /* Build the page
 217          */
 218         if (web_interface) {
 219                 avahi_build_page (hdl);
 220         }
 221
 222         hdl->action = send_page;
 223
 224         return ret_ok;
 225 }
 226
 227
 228 ret_t
 229 cherokee_handler_avahi_step (cherokee_handler_avahi_t *hdl, cherokee_buffer_t *buffer)
 230 {
 231         cherokee_buffer_add_buffer (buffer, &hdl->buffer);
 232         return ret_eof_have_data;
 233 }
 234
 235
 236 ret_t
 237 cherokee_handler_avahi_add_headers (cherokee_handler_avahi_t *hdl, cherokee_buffer_t *buffer)
 238 {
 239     if (hdl->buffer.len == 0) {
 240         cherokee_connection_t *conn = HANDLER_CONN(hdl);
 241         conn->error_code = http_not_found;
 242     }
 243
 244         cherokee_buffer_add_va (buffer, "Content-Length: %d"CRLF, hdl->buffer.len);
 245
 246         switch (hdl->action) {
 247         case send_page:
 248         default:
 249                 cherokee_buffer_add_str (buffer, "Content-Type: text/plain"CRLF);
 250                     break;
 251         }
 252
 253         return ret_ok;
 254 }
 255
 256
 257 /* Avahi example stuff */
 258
 259 static void resolve_callback(
 260     AvahiServiceResolver *r,
 261     AVAHI_GCC_UNUSED AvahiIfIndex interface,
 262     AVAHI_GCC_UNUSED AvahiProtocol protocol,
 263     AvahiResolverEvent event,
 264     const char *name,
 265     const char *type,
 266     const char *domain,
 267     const char *host_name,
 268     const AvahiAddress *address,
 269     uint16_t port,
 270     AvahiStringList *txt,
 271     AvahiLookupResultFlags flags,
 272     void* userdata) {
 273     assert(r);
 274
 275     /* Called whenever a service has been resolved successfully or timed out */
 276
 277     switch (event) {
 278         case AVAHI_RESOLVER_FAILURE:
 279             TRACE("avahi", "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
 280             break;
 281
 282         case AVAHI_RESOLVER_FOUND: {
 283             char a[AVAHI_ADDRESS_STR_MAX];
 284             cherokee_buffer_t buf = CHEROKEE_BUF_INIT;
 285             cherokee_buffer_t *buf2 = malloc(sizeof(cherokee_buffer_t));
 286
 287
 288 //            avahi_address_snprint(a, sizeof(a), address);
 289             cherokee_buffer_add (&buf, name, strlen(name));
 290             cherokee_buffer_init (buf2);
 291 //            cherokee_buffer_add (buf2, a, strlen(a));
 292             cherokee_buffer_add (buf2, host_name, strlen(host_name));
 293             cherokee_avl_r_add(&PROP_AVAHI(userdata)->entries, &buf, buf2);
 294             cherokee_buffer_mrproper(&buf);
 295
 296             TRACE("avahi", "Service '%s' of type '%s' in domain '%s':\n", name, type, domain);
 297         }
 298     }
 299
 300     avahi_service_resolver_free(r);
 301 }
 302
 303 static void browse_callback(
 304     AvahiServiceBrowser *b,
 305     AvahiIfIndex interface,
 306     AvahiProtocol protocol,
 307     AvahiBrowserEvent event,
 308     const char *name,
 309     const char *type,
 310     const char *domain,
 311     AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 312     void* userdata) {
 313     cherokee_handler_avahi_props_t *props = userdata;
 314     assert(b);
 315
 316     /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
 317
 318
 319     switch (event) {
 320         case AVAHI_BROWSER_FAILURE:
 321             TRACE("avahi", "(Browser) %s\n", avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))));
 322             avahi_service_browser_free(b);
 323             return;
 324
 325         case AVAHI_BROWSER_NEW:
 326             TRACE("avahi", "(Browser) NEW: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
 327
 328             /* We ignore the returned resolver object. In the callback
 329                function we free it. If the server is terminated before
 330                the callback function is called the server will free
 331                the resolver for us. */
 332
 333             if (!(avahi_service_resolver_new(avahi_service_browser_get_client(b), interface, protocol, name, type, domain, AVAHI_PROTO_UNSPEC, 0, resolve_callback, userdata)))
 334                 TRACE("avahi", "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))));
 335
 336             break;
 337
 338         case AVAHI_BROWSER_REMOVE: {
 339             void *val;
 340             cherokee_buffer_t buf = CHEROKEE_BUF_INIT;
 341             cherokee_buffer_add(&buf, name, strlen(name));
 342             if (cherokee_avl_r_del(&props->entries, &buf, &val) == ret_ok) {
 343                 cherokee_buffer_mrproper((cherokee_buffer_t *) val);
 344             }
 345             cherokee_buffer_mrproper(&buf);
 346
 347 //            cherokee_avl_r_del_ptr(&PROP_AVAHI(userdata)->entries, name, val);
 348
 349             TRACE("avahi", "%s, (Browser) REMOVE: service '%s' of type '%s' in domain '%s'\n", __func__, name, type, domain);
 350             break;
 351         }
 352
 353         case AVAHI_BROWSER_ALL_FOR_NOW:
 354         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 355             TRACE("avahi", "(Browser) %s\n", event == AVAHI_BROWSER_CACHE_EXHAUSTED ? "CACHE_EXHAUSTED" : "ALL_FOR_NOW");
 356             break;
 357     }
 358 }
 359
 360 static void client_callback(AvahiClient *c, AvahiClientState state, void * userdata) {
 361 //    assert(c);
 362
 363     cherokee_handler_avahi_props_t *props = userdata;
 364
 365     /* Called whenever the client or server state changes */
 366
 367     switch (state) {
 368         case AVAHI_CLIENT_S_RUNNING:
 369             /* create some browsers on the client object here, if you wish */
 370             if (!(props->sb = avahi_service_browser_new(c, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, props->service_type.buf, NULL, 0, browse_callback, props))) {
 371                 TRACE ("avahi", "Failed to create service browser: %s (%s)\n", avahi_strerror(avahi_client_errno(c)), props->service_type.buf);
 372             }
 373             break;
 374         case AVAHI_CLIENT_FAILURE: {
 375             int error;
 376             if (c)
 377                 avahi_client_free(c);
 378             props->client = avahi_client_new(avahi_threaded_poll_get(props->threaded_poll), AVAHI_CLIENT_NO_FAIL, client_callback, props, &error);
 379             break;
 380         }
 381         default:
 382             break;
 383     }
 384 }
 385
 386 ret_t
 387 cherokee_handler_avahi_props_init_base (cherokee_handler_avahi_props_t *props, module_func_props_free_t free_func)
 388 {
 389     cherokee_buffer_init (&props->service_type);
 390
 391     return cherokee_handler_props_init_base (HANDLER_PROPS(props), free_func);
 392 }