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 static ret_t
  52 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_mrproper (&props->entries, (cherokee_func_free_t) cherokee_buffer_mrproper);
  69 //    cherokee_avl_mrproper (&props->entries, NULL);
  70
  71         return cherokee_module_props_free_base (MODULE_PROPS(props));
  72 }
  73
  74
  75 ret_t
  76 cherokee_handler_avahi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
  77 {
  78         cherokee_list_t                      *i;
  79         cherokee_handler_avahi_props_t *props;
  80     int error;
  81
  82         if (*_props == NULL) {
  83                 CHEROKEE_NEW_STRUCT (n, handler_avahi_props);
  84
  85                 cherokee_module_props_init_base (MODULE_PROPS(n),
  86                                                  MODULE_PROPS_FREE(props_free));
  87
  88         /* Look at handler_avahi.h
  89          * This is an avahi of configuration.
  90          */
  91         cherokee_buffer_init (&n->service_type);
  92
  93                 *_props = MODULE_PROPS(n);
  94         }
  95
  96         props = PROP_AVAHI(*_props);
  97
  98         cherokee_config_node_foreach (i, conf) {
  99                 cherokee_config_node_t *subconf = CONFIG_NODE(i);
 100
 101         if (equal_buf_str (&subconf->key, "service_type")) {
 102             cherokee_buffer_add_buffer (&props->service_type, &subconf->val);
 103                 }
 104 /*        else {
 105                         PRINT_MSG ("ERROR: Handler file: Unknown key: '%s'\n", subconf->key.buf);
 106                         return ret_error;
 107                 }*/
 108         }
 109
 110     /* If the configuration for avahi was not set, we should not continue */
 111     if (props->service_type.len == 0) {
 112         return ret_error;
 113     }
 114
 115     props->client = NULL;
 116     props->sb = NULL;
 117     props->threaded_poll = NULL;
 118
 119     cherokee_avl_init(&props->entries);
 120
 121     if (!(props->threaded_poll = avahi_threaded_poll_new())) {
 122         return ret_error;
 123     }
 124
 125     if (!(props->client = avahi_client_new(avahi_threaded_poll_get(props->threaded_poll), 0, client_callback, props, &error))) {
 126         return ret_error;
 127     }
 128
 129     /* create some browsers on the client object here, if you wish */
 130     if (!(props->sb = avahi_service_browser_new(props->client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, props->service_type.buf, NULL, 0, browse_callback, props))) {
 131         TRACE ("avahi", "Failed to create service browser: %s (%s)\n", avahi_strerror(avahi_client_errno(props->client)), props->service_type.buf);
 132         return ret_error;
 133     }
 134
 135     /* Finally, start the event loop thread */
 136     if (avahi_threaded_poll_start(props->threaded_poll) < 0) {
 137         return ret_error;
 138     }
 139
 140
 141         return ret_ok;
 142 }
 143
 144 ret_t
 145 cherokee_handler_avahi_new  (cherokee_handler_t **hdl, cherokee_connection_t *cnt, cherokee_module_props_t *props)
 146 {
 147         ret_t ret;
 148
 149         CHEROKEE_NEW_STRUCT (n, handler_avahi);
 150
 151         /* Init the base class object
 152          */
 153         cherokee_handler_init_base(HANDLER(n), cnt, HANDLER_PROPS(props), PLUGIN_INFO_HANDLER_PTR(avahi));
 154
 155         MODULE(n)->init         = (handler_func_init_t) cherokee_handler_avahi_init;
 156         MODULE(n)->free         = (module_func_free_t) cherokee_handler_avahi_free;
 157         HANDLER(n)->step        = (handler_func_step_t) cherokee_handler_avahi_step;
 158         HANDLER(n)->add_headers = (handler_func_add_headers_t) cherokee_handler_avahi_add_headers;
 159
 160         HANDLER(n)->support = hsupport_length | hsupport_range;
 161
 162         /* Init
 163          */
 164         ret = cherokee_buffer_init (&n->buffer);
 165         if (unlikely(ret != ret_ok))
 166                 return ret;
 167
 168         ret = cherokee_buffer_ensure_size (&n->buffer, 4*1024);
 169         if (unlikely(ret != ret_ok))
 170                 return ret;
 171
 172         *hdl = HANDLER(n);
 173
 174         return ret_ok;
 175 }
 176
 177
 178 ret_t
 179 cherokee_handler_avahi_free (cherokee_handler_avahi_t *hdl)
 180 {
 181         cherokee_buffer_mrproper (&hdl->buffer);
 182
 183         return ret_ok;
 184 }
 185
 186 static ret_t
 187 while_func_entries (cherokee_buffer_t *key, void *value, void *param) {
 188     cherokee_buffer_t *buf = (cherokee_buffer_t *)param;
 189     cherokee_buffer_t *buf2 = (cherokee_buffer_t *)value;
 190
 191     cherokee_buffer_add_buffer (buf, key);
 192     cherokee_buffer_add_str (buf, " - ");
 193     cherokee_buffer_add_buffer (buf, buf2);
 194 //    cherokee_buffer_add (buf, value, strlen(value));
 195     cherokee_buffer_add_str (buf, "\n");
 196
 197     return ret_ok;
 198 }
 199
 200 static void
 201 avahi_build_page (cherokee_handler_avahi_t *hdl)
 202 {
 203     ret_t              ret;
 204     cherokee_buffer_t *buf;
 205
 206     /* Init
 207      */
 208     buf = &hdl->buffer;
 209
 210     /* Useful output
 211      */
 212
 213     /* First, block the event loop */
 214     avahi_threaded_poll_lock(HDL_AVAHI_PROPS(hdl)->threaded_poll);
 215
 216     /* Than, do your stuff */
 217     cherokee_avl_while (&HDL_AVAHI_PROPS(hdl)->entries, (cherokee_avl_while_func_t) while_func_entries, (void *) buf, NULL, NULL);
 218
 219     /* Finally, unblock the event loop */
 220     avahi_threaded_poll_unlock(HDL_AVAHI_PROPS(hdl)->threaded_poll);
 221 }
 222
 223 ret_t
 224 cherokee_handler_avahi_init (cherokee_handler_avahi_t *hdl)
 225 {
 226         ret_t   ret;
 227         void   *param;
 228         cint_t  web_interface = 1;
 229
 230         /* Build the page
 231          */
 232         if (web_interface) {
 233                 avahi_build_page (hdl);
 234         }
 235
 236         hdl->action = send_page;
 237
 238         return ret_ok;
 239 }
 240
 241
 242 ret_t
 243 cherokee_handler_avahi_step (cherokee_handler_avahi_t *hdl, cherokee_buffer_t *buffer)
 244 {
 245         cherokee_buffer_add_buffer (buffer, &hdl->buffer);
 246         return ret_eof_have_data;
 247 }
 248
 249
 250 ret_t
 251 cherokee_handler_avahi_add_headers (cherokee_handler_avahi_t *hdl, cherokee_buffer_t *buffer)
 252 {
 253     if (hdl->buffer.len == 0) {
 254         cherokee_connection_t *conn = HANDLER_CONN(hdl);
 255         conn->error_code = http_not_found;
 256     }
 257
 258         cherokee_buffer_add_va (buffer, "Content-Length: %d"CRLF, hdl->buffer.len);
 259
 260         switch (hdl->action) {
 261         case send_page:
 262         default:
 263                 cherokee_buffer_add_str (buffer, "Content-Type: text/plain"CRLF);
 264                     break;
 265         }
 266
 267         return ret_ok;
 268 }
 269
 270
 271 /* Avahi example stuff */
 272
 273 static void resolve_callback(
 274     AvahiServiceResolver *r,
 275     AVAHI_GCC_UNUSED AvahiIfIndex interface,
 276     AVAHI_GCC_UNUSED AvahiProtocol protocol,
 277     AvahiResolverEvent event,
 278     const char *name,
 279     const char *type,
 280     const char *domain,
 281     const char *host_name,
 282     const AvahiAddress *address,
 283     uint16_t port,
 284     AvahiStringList *txt,
 285     AvahiLookupResultFlags flags,
 286     void* userdata) {
 287     assert(r);
 288
 289     /* Called whenever a service has been resolved successfully or timed out */
 290
 291     switch (event) {
 292         case AVAHI_RESOLVER_FAILURE:
 293             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))));
 294             break;
 295
 296         case AVAHI_RESOLVER_FOUND: {
 297             char a[AVAHI_ADDRESS_STR_MAX], *t;
 298
 299             avahi_address_snprint(a, sizeof(a), address);
 300
 301             cherokee_buffer_t buf;
 302             cherokee_buffer_t buf2;
 303             cherokee_buffer_t *buf2a;
 304             cherokee_buffer_init(&buf);
 305             cherokee_buffer_init(&buf2);
 306             cherokee_buffer_add(&buf, name, strlen(name));
 307 //            cherokee_buffer_add(&buf2, a, strlen(a));
 308             cherokee_buffer_add (&buf2, host_name, strlen(host_name));
 309             cherokee_buffer_dup(&buf2, &buf2a);
 310             cherokee_avl_add(&PROP_AVAHI(userdata)->entries, &buf, buf2a);
 311             cherokee_buffer_mrproper(&buf);
 312             cherokee_buffer_mrproper(&buf2);
 313
 314 //            cherokee_avl_add_ptr (&PROP_AVAHI(userdata)->entries, name, (void *) host_name);
 315
 316             TRACE("avahi", "Service '%s' of type '%s' in domain '%s':\n", name, type, domain);
 317
 318             t = avahi_string_list_to_string(txt);
 319             TRACE("avahi",
 320                     "\t%s:%u (%s)\n"
 321                     "\tTXT=%s\n"
 322                     "\tcookie is %u\n"
 323                     "\tis_local: %i\n"
 324                     "\tour_own: %i\n"
 325                     "\twide_area: %i\n"
 326                     "\tmulticast: %i\n"
 327                     "\tcached: %i\n",
 328                     host_name, port, a,
 329                     t,
 330                     avahi_string_list_get_service_cookie(txt),
 331                     !!(flags & AVAHI_LOOKUP_RESULT_LOCAL),
 332                     !!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN),
 333                     !!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA),
 334                     !!(flags & AVAHI_LOOKUP_RESULT_MULTICAST),
 335                     !!(flags & AVAHI_LOOKUP_RESULT_CACHED));
 336
 337             avahi_free(t);
 338         }
 339     }
 340
 341     avahi_service_resolver_free(r);
 342 }
 343
 344 static void browse_callback(
 345     AvahiServiceBrowser *b,
 346     AvahiIfIndex interface,
 347     AvahiProtocol protocol,
 348     AvahiBrowserEvent event,
 349     const char *name,
 350     const char *type,
 351     const char *domain,
 352     AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 353     void* userdata) {
 354
 355     AvahiClient *c = PROP_AVAHI(userdata)->client;
 356     assert(b);
 357
 358     /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
 359
 360     switch (event) {
 361         case AVAHI_BROWSER_FAILURE:
 362             TRACE("avahi", "(Browser) %s\n", avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))));
 363             avahi_threaded_poll_stop(PROP_AVAHI(userdata)->threaded_poll);
 364             return;
 365
 366         case AVAHI_BROWSER_NEW:
 367             TRACE("avahi", "(Browser) NEW: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
 368
 369             /* We ignore the returned resolver object. In the callback
 370                function we free it. If the server is terminated before
 371                the callback function is called the server will free
 372                the resolver for us. */
 373
 374             if (!(avahi_service_resolver_new(c, interface, protocol, name, type, domain, AVAHI_PROTO_UNSPEC, 0, resolve_callback, userdata)))
 375                 TRACE("avahi", "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_client_errno(c)));
 376
 377             break;
 378
 379         case AVAHI_BROWSER_REMOVE: {
 380             void **val;
 381             cherokee_buffer_t buf;
 382             cherokee_buffer_init(&buf);
 383             cherokee_buffer_add(&buf, name, strlen(name));
 384             if (cherokee_avl_del(&PROP_AVAHI(userdata)->entries, &buf, val) == ret_ok) {
 385                 cherokee_buffer_mrproper((cherokee_buffer_t *) *val);
 386             }
 387             cherokee_buffer_mrproper(&buf);
 388
 389 //            cherokee_avl_del_ptr(&PROP_AVAHI(userdata)->entries, name, val);
 390
 391             TRACE("avahi", "(Browser) REMOVE: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
 392             break;
 393         }
 394
 395         case AVAHI_BROWSER_ALL_FOR_NOW:
 396         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 397             TRACE("avahi", "(Browser) %s\n", event == AVAHI_BROWSER_CACHE_EXHAUSTED ? "CACHE_EXHAUSTED" : "ALL_FOR_NOW");
 398             break;
 399     }
 400 }
 401
 402 static void client_callback(AvahiClient *c, AvahiClientState state, void * userdata) {
 403     assert(c);
 404
 405     /* Called whenever the client or server state changes */
 406
 407     if (state == AVAHI_CLIENT_FAILURE) {
 408         TRACE("avahi", "Server connection failure: %s\n", avahi_strerror(avahi_client_errno(c)));
 409         avahi_threaded_poll_stop(PROP_AVAHI(userdata)->threaded_poll);
 410     }
 411 }
 412
 413 ret_t
 414 cherokee_handler_avahi_props_init_base (cherokee_handler_avahi_props_t *props, module_func_props_free_t free_func)
 415 {
 416     cherokee_buffer_init (&props->service_type);
 417
 418     return cherokee_handler_props_init_base (HANDLER_PROPS(props), free_func);
 419 }