cups-avahi-no-threaded.patch

   1 diff -up cups-2.0.2/scheduler/avahi.c.KUoOri cups-2.0.2/scheduler/avahi.c
   2 --- cups-2.0.2/scheduler/avahi.c.KUoOri 2015-02-10 13:47:38.620396709 +0100
   3 +++ cups-2.0.2/scheduler/avahi.c        2015-02-10 13:47:38.620396709 +0100
   4 @@ -0,0 +1,441 @@
   5 +/*
   6 + * "$Id$"
   7 + *
   8 + *   Avahi poll implementation for the CUPS scheduler.
   9 + *
  10 + *   Copyright (C) 2010, 2011 Red Hat, Inc.
  11 + *   Authors:
  12 + *    Tim Waugh <twaugh@redhat.com>
  13 + *
  14 + *   Redistribution and use in source and binary forms, with or without
  15 + *   modification, are permitted provided that the following conditions
  16 + *   are met:
  17 + *
  18 + *   Redistributions of source code must retain the above copyright
  19 + *   notice, this list of conditions and the following disclaimer.
  20 + *
  21 + *   Redistributions in binary form must reproduce the above copyright
  22 + *   notice, this list of conditions and the following disclaimer in the
  23 + *   documentation and/or other materials provided with the distribution.
  24 + *
  25 + *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26 + *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27 + *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  28 + *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  29 + *   COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  30 + *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  31 + *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  32 + *   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33 + *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  34 + *   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35 + *   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  36 + *   OF THE POSSIBILITY OF SUCH DAMAGE.
  37 + *
  38 + * Contents:
  39 + *
  40 + *   watch_read_cb         - Read callback for file descriptor
  41 + *   watch_write_cb        - Write callback for file descriptor
  42 + *   watched_fd_add_select() - Call cupsdAddSelect() as needed
  43 + *   watch_new()           - Create a new file descriptor watch
  44 + *   watch_free()          - Free a file descriptor watch
  45 + *   watch_update()        - Update watched events for a file descriptor
  46 + *   watch_get_events()    - Get events that happened for a file descriptor
  47 + *   timeout_cb()          - Run a timed Avahi callback
  48 + *   timeout_new()         - Set a wakeup time
  49 + *   timeout_update()      - Update the expiration time for a timeout
  50 + *   timeout_free()        - Free a timeout
  51 + *   compare_watched_fds() - Compare watched file descriptors for array sorting
  52 + *   avahi_cups_poll_new() - Create a new Avahi main loop object for CUPS
  53 + *   avahi_cups_poll_free() - Free an Avahi main loop object for CUPS
  54 + *   avahi_cups_poll_get() - Get the abstract poll API structure
  55 + */
  56 +
  57 +#include <config.h>
  58 +
  59 +#ifdef HAVE_AVAHI /* Applies to entire file... */
  60 +
  61 +/*
  62 + * Include necessary headers...
  63 + */
  64 +
  65 +#include "cupsd.h"
  66 +
  67 +#if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO)
  68 +#  include <malloc.h>
  69 +#endif /* HAVE_MALLOC_H && HAVE_MALLINFO */
  70 +
  71 +#ifdef HAVE_AVAHI
  72 +#  include <avahi-common/timeval.h>
  73 +#endif /* HAVE_AVAHI */
  74 +
  75 +
  76 +typedef struct
  77 +{
  78 +  AvahiCupsPoll *cups_poll;
  79 +
  80 +  int fd;
  81 +  AvahiWatchEvent occurred;
  82 +  cups_array_t *watches;
  83 +} cupsd_watched_fd_t;
  84 +
  85 +struct AvahiWatch
  86 +{
  87 +  cupsd_watched_fd_t *watched_fd;
  88 +
  89 +  AvahiWatchEvent events;
  90 +  AvahiWatchCallback callback;
  91 +  void *userdata;
  92 +};
  93 +
  94 +struct AvahiTimeout
  95 +{
  96 +  AvahiCupsPoll *cups_poll;
  97 +  AvahiTimeoutCallback callback;
  98 +  void *userdata;
  99 +  cupsd_timeout_t *cupsd_timeout;
 100 +};
 101 +
 102 +/*
 103 + * Local functions...
 104 + */
 105 +
 106 +static AvahiWatch *    watch_new(const AvahiPoll *api,
 107 +                                 int fd,
 108 +                                 AvahiWatchEvent events,
 109 +                                 AvahiWatchCallback callback,
 110 +                                 void *userdata);
 111 +static void            watch_free(AvahiWatch *watch);
 112 +static void            watch_update(AvahiWatch *watch,
 113 +                                    AvahiWatchEvent events);
 114 +static AvahiWatchEvent watch_get_events(AvahiWatch *watch);
 115 +
 116 +
 117 +/*
 118 + * 'watch_read_cb' - Read callback for file descriptor
 119 + */
 120 +
 121 +static void
 122 +watch_read_cb (void *userdata)
 123 +{
 124 +  AvahiWatch *watch;
 125 +  cupsd_watched_fd_t *watched_fd = userdata;
 126 +  watched_fd->occurred |= AVAHI_WATCH_IN;
 127 +  for (watch = (AvahiWatch *)cupsArrayFirst(watched_fd->watches);
 128 +       watch;
 129 +       watch = (AvahiWatch *)cupsArrayNext(watched_fd->watches))
 130 +  {
 131 +    if (watch->events & watched_fd->occurred)
 132 +    {
 133 +      (watch->callback) (watch, watched_fd->fd,
 134 +                        AVAHI_WATCH_IN, watch->userdata);
 135 +      watched_fd->occurred &= ~AVAHI_WATCH_IN;
 136 +      break;
 137 +    }
 138 +  }
 139 +}
 140 +
 141 +
 142 +/*
 143 + * 'watch_write_cb' - Write callback for file descriptor
 144 + */
 145 +
 146 +static void
 147 +watch_write_cb (void *userdata)
 148 +{
 149 +  AvahiWatch *watch;
 150 +  cupsd_watched_fd_t *watched_fd = userdata;
 151 +  watched_fd->occurred |= AVAHI_WATCH_OUT;
 152 +  for (watch = (AvahiWatch *)cupsArrayFirst(watched_fd->watches);
 153 +       watch;
 154 +       watch = (AvahiWatch *)cupsArrayNext(watched_fd->watches))
 155 +  {
 156 +    if (watch->events & watched_fd->occurred)
 157 +    {
 158 +      (watch->callback) (watch, watched_fd->fd,
 159 +                        AVAHI_WATCH_OUT, watch->userdata);
 160 +      watched_fd->occurred &= ~AVAHI_WATCH_OUT;
 161 +      break;
 162 +    }
 163 +  }
 164 +}
 165 +
 166 +
 167 +/*
 168 + * 'watched_fd_add_select' - Call cupsdAddSelect() as needed
 169 + */
 170 +
 171 +static int                                             /* O - Watches? */
 172 +watched_fd_add_select (cupsd_watched_fd_t *watched_fd)
 173 +{
 174 +  AvahiWatch *watch;
 175 +  cupsd_selfunc_t read_cb = NULL, write_cb = NULL;
 176 +  int any_watches = 0;
 177 +
 178 +  for (watch = (AvahiWatch *)cupsArrayFirst(watched_fd->watches);
 179 +       watch;
 180 +       watch = (AvahiWatch *)cupsArrayNext(watched_fd->watches))
 181 +  {
 182 +    any_watches = 1;
 183 +    if (watch->events & (AVAHI_WATCH_IN |
 184 +                            AVAHI_WATCH_ERR |
 185 +                            AVAHI_WATCH_HUP))
 186 +    {
 187 +      read_cb = (cupsd_selfunc_t)watch_read_cb;
 188 +      if (write_cb != NULL)
 189 +       break;
 190 +    }
 191 +
 192 +    if (watch->events & AVAHI_WATCH_OUT)
 193 +    {
 194 +      write_cb = (cupsd_selfunc_t)watch_write_cb;
 195 +      if (read_cb != NULL)
 196 +       break;
 197 +    }
 198 +  }
 199 +
 200 +  if (read_cb || write_cb)
 201 +    cupsdAddSelect (watched_fd->fd, read_cb, write_cb, watched_fd);
 202 +  else
 203 +    cupsdRemoveSelect (watched_fd->fd);
 204 +
 205 +  return (any_watches);
 206 +}
 207 +
 208 +/*
 209 + * 'watch_new' - Create a new file descriptor watch
 210 + */
 211 +
 212 +static AvahiWatch *
 213 +watch_new (const AvahiPoll *api,
 214 +          int fd,
 215 +          AvahiWatchEvent events,
 216 +          AvahiWatchCallback callback,
 217 +          void *userdata)
 218 +{
 219 +  cupsd_watched_fd_t key, *watched_fd;
 220 +  AvahiCupsPoll *cups_poll = api->userdata;
 221 +  AvahiWatch *watch = malloc(sizeof(AvahiWatch));
 222 +  if (watch == NULL)
 223 +    return (NULL);
 224 +
 225 +  watch->events = events;
 226 +  watch->callback = callback;
 227 +  watch->userdata = userdata;
 228 +
 229 +  key.fd = fd;
 230 +  watched_fd = cupsArrayFind (cups_poll->watched_fds, &key);
 231 +  if (watched_fd == NULL)
 232 +  {
 233 +    watched_fd = malloc(sizeof(cupsd_watched_fd_t));
 234 +    if (watched_fd == NULL)
 235 +    {
 236 +      free (watch);
 237 +      return (NULL);
 238 +    }
 239 +
 240 +    watched_fd->fd = fd;
 241 +    watched_fd->occurred = 0;
 242 +    watched_fd->cups_poll = cups_poll;
 243 +    watched_fd->watches = cupsArrayNew (NULL, NULL);
 244 +    cupsArrayAdd (cups_poll->watched_fds, watched_fd);
 245 +  }
 246 +
 247 +  watch->watched_fd = watched_fd;
 248 +  cupsArrayAdd(watched_fd->watches, watch);
 249 +  watched_fd_add_select (watched_fd);
 250 +  return (watch);
 251 +}
 252 +
 253 +
 254 +/*
 255 + * 'watch_free' - Free a file descriptor watch
 256 + */
 257 +
 258 +static void
 259 +watch_free (AvahiWatch *watch)
 260 +{
 261 +  cupsd_watched_fd_t *watched_fd = watch->watched_fd;
 262 +  AvahiCupsPoll *cups_poll = watched_fd->cups_poll;
 263 +
 264 +  cupsArrayRemove (watched_fd->watches, watch);
 265 +  free (watch);
 266 +
 267 +  if (!watched_fd_add_select (watched_fd))
 268 +  {
 269 +    /* No more watches */
 270 +    cupsArrayRemove (cups_poll->watched_fds, watched_fd);
 271 +    free (watched_fd);
 272 +  }
 273 +}
 274 +
 275 +
 276 +/*
 277 + * 'watch_update' - Update watched events for a file descriptor
 278 + */
 279 +
 280 +static void
 281 +watch_update (AvahiWatch *watch,
 282 +             AvahiWatchEvent events)
 283 +{
 284 +  watch->events = events;
 285 +  watched_fd_add_select (watch->watched_fd);
 286 +}
 287 +
 288 +
 289 +/*
 290 + * 'watch_get_events' - Get events that happened for a file descriptor
 291 + */
 292 +
 293 +static AvahiWatchEvent
 294 +watch_get_events (AvahiWatch *watch)
 295 +{
 296 +  return (watch->watched_fd->occurred);
 297 +}
 298 +
 299 +
 300 +/*
 301 + * 'timeout_cb()' - Run a timed Avahi callback
 302 + */
 303 +
 304 +static void
 305 +timeout_cb (cupsd_timeout_t *cupsd_timeout, void *userdata)
 306 +{
 307 +  AvahiTimeout *timeout = userdata;
 308 +  (timeout->callback) (timeout, timeout->userdata);
 309 +}
 310 +
 311 +
 312 +/*
 313 + * 'timeout_new' - Set a wakeup time
 314 + */
 315 +
 316 +static AvahiTimeout *
 317 +timeout_new (const AvahiPoll *api,
 318 +            const struct timeval *tv,
 319 +            AvahiTimeoutCallback callback,
 320 +            void *userdata)
 321 +{
 322 +  AvahiTimeout *timeout;
 323 +  AvahiCupsPoll *cups_poll = api->userdata;
 324 +
 325 +  timeout = malloc(sizeof(AvahiTimeout));
 326 +  if (timeout == NULL)
 327 +    return (NULL);
 328 +
 329 +  timeout->cups_poll = cups_poll;
 330 +  timeout->callback = callback;
 331 +  timeout->userdata = userdata;
 332 +  timeout->cupsd_timeout = cupsdAddTimeout (tv,
 333 +                                           (cupsd_timeoutfunc_t)timeout_cb,
 334 +                                           timeout);
 335 +  cupsArrayAdd (cups_poll->timeouts, timeout);
 336 +  return (timeout);
 337 +}
 338 +
 339 +
 340 +/*
 341 + * 'timeout_update' - Update the expiration time for a timeout
 342 + */
 343 +
 344 +static void
 345 +timeout_update (AvahiTimeout *timeout,
 346 +               const struct timeval *tv)
 347 +{
 348 +  cupsdUpdateTimeout (timeout->cupsd_timeout, tv);
 349 +}
 350 +
 351 +
 352 +/*
 353 + * ' timeout_free' - Free a timeout
 354 + */
 355 +
 356 +static void
 357 +timeout_free (AvahiTimeout *timeout)
 358 +{
 359 +  cupsArrayRemove (timeout->cups_poll->timeouts, timeout);
 360 +  cupsdRemoveTimeout (timeout->cupsd_timeout);
 361 +  free (timeout);
 362 +}
 363 +
 364 +
 365 +/*
 366 + * 'compare_watched_fds' - Compare watched file descriptors for array sorting
 367 + */
 368 +static int
 369 +compare_watched_fds(cupsd_watched_fd_t *p0,
 370 +                   cupsd_watched_fd_t *p1)
 371 +{
 372 +  /*
 373 +   * Compare by fd (no two elements have the same fd)
 374 +   */
 375 +
 376 +  if (p0->fd == p1->fd)
 377 +    return 0;
 378 +
 379 +  return (p0->fd < p1->fd ? -1 : 1);
 380 +}
 381 +
 382 +
 383 +/*
 384 + * 'avahi_cups_poll_new' - Create a new Avahi main loop object for CUPS
 385 + */
 386 +
 387 +AvahiCupsPoll *
 388 +avahi_cups_poll_new (void)
 389 +{
 390 +  AvahiCupsPoll *cups_poll = malloc(sizeof(AvahiCupsPoll));
 391 +  if (cups_poll == NULL)
 392 +    return (NULL);
 393 +
 394 +  cups_poll->watched_fds = cupsArrayNew ((cups_array_func_t)compare_watched_fds,
 395 +                                        NULL);
 396 +  cups_poll->timeouts = cupsArrayNew (NULL, NULL);
 397 +
 398 +  cups_poll->api.userdata = cups_poll;
 399 +  cups_poll->api.watch_new = watch_new;
 400 +  cups_poll->api.watch_free = watch_free;
 401 +  cups_poll->api.watch_update = watch_update;
 402 +  cups_poll->api.watch_get_events = watch_get_events;
 403 +
 404 +  cups_poll->api.timeout_new = timeout_new;
 405 +  cups_poll->api.timeout_update = timeout_update;
 406 +  cups_poll->api.timeout_free = timeout_free;
 407 +
 408 +  return (cups_poll);
 409 +}
 410 +
 411 +
 412 +/*
 413 + * 'avahi_cups_poll_free' - Free an Avahi main loop object for CUPS
 414 + */
 415 +void
 416 +avahi_cups_poll_free (AvahiCupsPoll *cups_poll)
 417 +{
 418 +  cupsd_watched_fd_t *watched_fd;
 419 +
 420 +  for (watched_fd = (cupsd_watched_fd_t*)cupsArrayFirst(cups_poll->watched_fds);
 421 +       watched_fd;
 422 +       watched_fd = (cupsd_watched_fd_t*)cupsArrayNext(cups_poll->watched_fds))
 423 +    cupsArrayClear (watched_fd->watches);
 424 +
 425 +  cupsArrayClear (cups_poll->watched_fds);
 426 +  cupsArrayClear (cups_poll->timeouts);
 427 +}
 428 +
 429 +
 430 +/*
 431 + * 'avahi_cups_poll_get' - Get the abstract poll API structure
 432 + */
 433 +
 434 +const AvahiPoll *
 435 +avahi_cups_poll_get (AvahiCupsPoll *cups_poll)
 436 +{
 437 +  return (&cups_poll->api);
 438 +}
 439 +
 440 +
 441 +#endif /* HAVE_AVAHI ... from top of file */
 442 +
 443 +/*
 444 + * End of "$Id$".
 445 + */
 446 diff -up cups-2.0.2/scheduler/avahi.h.KUoOri cups-2.0.2/scheduler/avahi.h
 447 --- cups-2.0.2/scheduler/avahi.h.KUoOri 2015-02-10 13:47:38.620396709 +0100
 448 +++ cups-2.0.2/scheduler/avahi.h        2015-02-10 13:47:38.620396709 +0100
 449 @@ -0,0 +1,69 @@
 450 +/*
 451 + * "$Id$"
 452 + *
 453 + *   Avahi poll implementation for the CUPS scheduler.
 454 + *
 455 + *   Copyright (C) 2010, 2011 Red Hat, Inc.
 456 + *   Authors:
 457 + *    Tim Waugh <twaugh@redhat.com>
 458 + *
 459 + *   Redistribution and use in source and binary forms, with or without
 460 + *   modification, are permitted provided that the following conditions
 461 + *   are met:
 462 + *
 463 + *   Redistributions of source code must retain the above copyright
 464 + *   notice, this list of conditions and the following disclaimer.
 465 + *
 466 + *   Redistributions in binary form must reproduce the above copyright
 467 + *   notice, this list of conditions and the following disclaimer in the
 468 + *   documentation and/or other materials provided with the distribution.
 469 + *
 470 + *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 471 + *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 472 + *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 473 + *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 474 + *   COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 475 + *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 476 + *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 477 + *   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 478 + *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 479 + *   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 480 + *   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 481 + *   OF THE POSSIBILITY OF SUCH DAMAGE.
 482 + */
 483 +
 484 +#include <config.h>
 485 +
 486 +#ifdef HAVE_AVAHI
 487 +#  include <avahi-client/client.h>
 488 +#  include <avahi-client/publish.h>
 489 +#endif /* HAVE_AVAHI */
 490 +
 491 +#ifdef HAVE_AUTHORIZATION_H
 492 +#  include <Security/Authorization.h>
 493 +#endif /* HAVE_AUTHORIZATION_H */
 494 +
 495 +
 496 +#ifdef HAVE_AVAHI
 497 +typedef struct
 498 +{
 499 +    AvahiPoll api;
 500 +    cups_array_t *watched_fds;
 501 +    cups_array_t *timeouts;
 502 +} AvahiCupsPoll;
 503 +#endif /* HAVE_AVAHI */
 504 +
 505 +/*
 506 + * Prototypes...
 507 + */
 508 +
 509 +#ifdef HAVE_AVAHI
 510 +extern AvahiCupsPoll * avahi_cups_poll_new(void);
 511 +extern void            avahi_cups_poll_free(AvahiCupsPoll *cups_poll);
 512 +extern const AvahiPoll *avahi_cups_poll_get(AvahiCupsPoll *cups_poll);
 513 +#endif /* HAVE_AVAHI */
 514 +
 515 +
 516 +/*
 517 + * End of "$Id$".
 518 + */
 519 diff -up cups-2.0.2/scheduler/cupsd.h.KUoOri cups-2.0.2/scheduler/cupsd.h
 520 --- cups-2.0.2/scheduler/cupsd.h.KUoOri 2014-03-21 17:42:53.000000000 +0100
 521 +++ cups-2.0.2/scheduler/cupsd.h        2015-02-10 13:47:38.624396652 +0100
 522 @@ -119,6 +119,7 @@ extern const char *cups_hstrerror(int);
 523  #include "colorman.h"
 524  #include "conf.h"
 525  #include "banners.h"
 526 +#include "avahi.h"
 527  #include "dirsvc.h"
 528  #include "network.h"
 529  #include "subscriptions.h"
 530 @@ -139,6 +140,15 @@ extern const char *cups_hstrerror(int);
 531
 532  typedef void (*cupsd_selfunc_t)(void *data);
 533
 534 +#ifdef HAVE_AVAHI
 535 +/*
 536 + * Timeout callback function type...
 537 + */
 538 +
 539 +typedef struct _cupsd_timeout_s cupsd_timeout_t;
 540 +typedef void (*cupsd_timeoutfunc_t)(cupsd_timeout_t *timeout, void *data);
 541 +#endif /* HAVE_AVAHI */
 542 +
 543
 544  /*
 545   * Globals...
 546 @@ -163,6 +173,10 @@ VAR int                    OnDemand        VALUE(0);
 547                                         /* Launched on demand */
 548  #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
 549
 550 +#ifdef HAVE_AVAHI
 551 +VAR cups_array_t *Timeouts;            /* Timed callbacks for main loop */
 552 +#endif /* HAVE_AVAHI */
 553 +
 554
 555  /*
 556   * Prototypes...
 557 @@ -226,6 +240,17 @@ extern void                cupsdStopSelect(void);
 558  extern void            cupsdStartServer(void);
 559  extern void            cupsdStopServer(void);
 560
 561 +#ifdef HAVE_AVAHI
 562 +extern void     cupsdInitTimeouts(void);
 563 +extern cupsd_timeout_t *cupsdAddTimeout (const struct timeval *tv,
 564 +                                        cupsd_timeoutfunc_t cb,
 565 +                                        void *data);
 566 +extern cupsd_timeout_t *cupsdNextTimeout (long *delay);
 567 +extern void     cupsdRunTimeout (cupsd_timeout_t *timeout);
 568 +extern void     cupsdUpdateTimeout (cupsd_timeout_t *timeout,
 569 +                                   const struct timeval *tv);
 570 +extern void     cupsdRemoveTimeout (cupsd_timeout_t *timeout);
 571 +#endif /* HAVE_AVAHI */
 572
 573  /*
 574   * End of "$Id: cupsd.h 11717 2014-03-21 16:42:53Z msweet $".
 575 diff -up cups-2.0.2/scheduler/dirsvc.c.KUoOri cups-2.0.2/scheduler/dirsvc.c
 576 --- cups-2.0.2/scheduler/dirsvc.c.KUoOri        2015-01-30 17:16:12.000000000 +0100
 577 +++ cups-2.0.2/scheduler/dirsvc.c       2015-02-10 13:50:47.131728120 +0100
 578 @@ -195,7 +195,7 @@ cupsdStartBrowsing(void)
 579      cupsdUpdateDNSSDName();
 580
 581  #  else /* HAVE_AVAHI */
 582 -    if ((DNSSDMaster = avahi_threaded_poll_new()) == NULL)
 583 +    if ((DNSSDMaster = avahi_cups_poll_new()) == NULL)
 584      {
 585        cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to create DNS-SD thread.");
 586
 587 @@ -206,7 +206,7 @@ cupsdStartBrowsing(void)
 588      {
 589        int error;                       /* Error code, if any */
 590
 591 -      DNSSDClient = avahi_client_new(avahi_threaded_poll_get(DNSSDMaster), AVAHI_CLIENT_NO_FAIL, dnssdClientCallback, NULL, &error);
 592 +      DNSSDClient = avahi_client_new(avahi_cups_poll_get(DNSSDMaster), AVAHI_CLIENT_NO_FAIL, dnssdClientCallback, NULL, &error);
 593
 594        if (DNSSDClient == NULL)
 595        {
 596 @@ -217,11 +217,9 @@ cupsdStartBrowsing(void)
 597          if (FatalErrors & CUPSD_FATAL_BROWSE)
 598           cupsdEndProcess(getpid(), 0);
 599
 600 -        avahi_threaded_poll_free(DNSSDMaster);
 601 +        avahi_cups_poll_free(DNSSDMaster);
 602          DNSSDMaster = NULL;
 603        }
 604 -      else
 605 -       avahi_threaded_poll_start(DNSSDMaster);
 606      }
 607  #  endif /* HAVE_DNSSD */
 608    }
 609 @@ -608,7 +606,7 @@ dnssdClientCallback(
 610           * Renew Avahi client...
 611           */
 612
 613 -         DNSSDClient = avahi_client_new(avahi_threaded_poll_get(DNSSDMaster), AVAHI_CLIENT_NO_FAIL, dnssdClientCallback, NULL, &error);
 614 +         DNSSDClient = avahi_client_new(avahi_cups_poll_get(DNSSDMaster), AVAHI_CLIENT_NO_FAIL, dnssdClientCallback, NULL, &error);
 615
 616           if (!DNSSDClient)
 617           {
 618 @@ -672,13 +670,7 @@ dnssdDeregisterInstance(
 619    DNSServiceRefDeallocate(*srv);
 620
 621  #  else /* HAVE_AVAHI */
 622 -  if (!from_callback)
 623 -    avahi_threaded_poll_lock(DNSSDMaster);
 624 -
 625    avahi_entry_group_free(*srv);
 626 -
 627 -  if (!from_callback)
 628 -    avahi_threaded_poll_unlock(DNSSDMaster);
 629  #  endif /* HAVE_DNSSD */
 630
 631    *srv = NULL;
 632 @@ -999,16 +991,10 @@ dnssdRegisterInstance(
 633    (void)commit;
 634
 635  #  else /* HAVE_AVAHI */
 636 -  if (!from_callback)
 637 -    avahi_threaded_poll_lock(DNSSDMaster);
 638 -
 639    if (!*srv)
 640      *srv = avahi_entry_group_new(DNSSDClient, dnssdRegisterCallback, NULL);
 641    if (!*srv)
 642    {
 643 -    if (!from_callback)
 644 -      avahi_threaded_poll_unlock(DNSSDMaster);
 645 -
 646      cupsdLogMessage(CUPSD_LOG_WARN, "DNS-SD registration of \"%s\" failed: %s",
 647                      name, dnssdErrorString(avahi_client_errno(DNSSDClient)));
 648      return (0);
 649 @@ -1123,9 +1109,6 @@ dnssdRegisterInstance(
 650        cupsdLogMessage(CUPSD_LOG_DEBUG, "DNS-SD commit of \"%s\" failed.",
 651                        name);
 652    }
 653 -
 654 -  if (!from_callback)
 655 -    avahi_threaded_poll_unlock(DNSSDMaster);
 656  #  endif /* HAVE_DNSSD */
 657
 658    if (error)
 659 @@ -1296,9 +1279,6 @@ dnssdStop(void)
 660    DNSSDMaster = NULL;
 661
 662  #  else /* HAVE_AVAHI */
 663 -  if (DNSSDMaster)
 664 -    avahi_threaded_poll_stop(DNSSDMaster);
 665 -
 666    if (DNSSDClient)
 667    {
 668      avahi_client_free(DNSSDClient);
 669 @@ -1307,7 +1287,7 @@ dnssdStop(void)
 670
 671    if (DNSSDMaster)
 672    {
 673 -    avahi_threaded_poll_free(DNSSDMaster);
 674 +    avahi_cups_poll_free(DNSSDMaster);
 675      DNSSDMaster = NULL;
 676    }
 677  #  endif /* HAVE_DNSSD */
 678 diff -up cups-2.0.2/scheduler/dirsvc.h.KUoOri cups-2.0.2/scheduler/dirsvc.h
 679 --- cups-2.0.2/scheduler/dirsvc.h.KUoOri        2013-05-29 13:51:34.000000000 +0200
 680 +++ cups-2.0.2/scheduler/dirsvc.h       2015-02-10 13:47:38.640396426 +0100
 681 @@ -51,7 +51,7 @@ VAR cups_array_t      *DNSSDPrinters  VALUE(NU
 682  VAR DNSServiceRef      DNSSDMaster     VALUE(NULL);
 683                                         /* Master DNS-SD service reference */
 684  #  else /* HAVE_AVAHI */
 685 -VAR AvahiThreadedPoll  *DNSSDMaster    VALUE(NULL);
 686 +VAR AvahiCupsPoll      *DNSSDMaster    VALUE(NULL);
 687                                         /* Master polling interface for Avahi */
 688  VAR AvahiClient                *DNSSDClient    VALUE(NULL);
 689                                         /* Client information */
 690 diff -up cups-2.0.2/scheduler/main.c.KUoOri cups-2.0.2/scheduler/main.c
 691 --- cups-2.0.2/scheduler/main.c.KUoOri  2015-02-10 13:40:24.295545063 +0100
 692 +++ cups-2.0.2/scheduler/main.c 2015-02-10 13:47:38.641396412 +0100
 693 @@ -129,6 +129,10 @@ main(int  argc,                            /* I - Number of comm
 694    int                  service_idle_exit;
 695                                         /* Idle exit on select timeout? */
 696  #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
 697 +#ifdef HAVE_AVAHI
 698 +  cupsd_timeout_t      *tmo;           /* Next scheduled timed callback */
 699 +  long                 tmo_delay;      /* Time before it must be called */
 700 +#endif /* HAVE_AVAHI */
 701
 702
 703  #ifdef HAVE_GETEUID
 704 @@ -577,6 +581,14 @@ main(int  argc,                            /* I - Number of comm
 705
 706    httpInitialize();
 707
 708 +#ifdef HAVE_AVAHI
 709 + /*
 710 +  * Initialize timed callback structures.
 711 +  */
 712 +
 713 +  cupsdInitTimeouts();
 714 +#endif /* HAVE_AVAHI */
 715 +
 716    cupsdStartServer();
 717
 718   /*
 719 @@ -883,6 +895,16 @@ main(int  argc,                            /* I - Number of comm
 720      }
 721  #endif /* __APPLE__ */
 722
 723 +#ifdef HAVE_AVAHI
 724 +   /*
 725 +    * If a timed callback is due, run it.
 726 +    */
 727 +
 728 +    tmo = cupsdNextTimeout (&tmo_delay);
 729 +    if (tmo && tmo_delay == 0)
 730 +      cupsdRunTimeout (tmo);
 731 +#endif /* HAVE_AVAHI */
 732 +
 733  #ifndef __APPLE__
 734     /*
 735      * Update the network interfaces once a minute...
 736 @@ -1574,6 +1596,10 @@ select_timeout(int fds)                  /* I - Number
 737    cupsd_job_t          *job;           /* Job information */
 738    cupsd_subscription_t *sub;           /* Subscription information */
 739    const char           *why;           /* Debugging aid */
 740 +#ifdef HAVE_AVAHI
 741 +  cupsd_timeout_t      *tmo;           /* Timed callback */
 742 +  long                 tmo_delay;      /* Seconds before calling it */
 743 +#endif /* HAVE_AVAHI */
 744
 745
 746    cupsdLogMessage(CUPSD_LOG_DEBUG2, "select_timeout: JobHistoryUpdate=%ld",
 747 @@ -1619,6 +1645,19 @@ select_timeout(int fds)                  /* I - Number
 748    }
 749  #endif /* __APPLE__ */
 750
 751 +#ifdef HAVE_AVAHI
 752 + /*
 753 +  * See if there are any scheduled timed callbacks to run.
 754 +  */
 755 +
 756 +  if ((tmo = cupsdNextTimeout(&tmo_delay)) != NULL &&
 757 +      (now + tmo_delay) < timeout)
 758 +  {
 759 +    timeout = tmo_delay;
 760 +    why = "run a timed callback";
 761 +  }
 762 +#endif /* HAVE_AVAHI */
 763 +
 764   /*
 765    * Check whether we are accepting new connections...
 766    */
 767 diff -up cups-2.0.2/scheduler/Makefile.KUoOri cups-2.0.2/scheduler/Makefile
 768 --- cups-2.0.2/scheduler/Makefile.KUoOri        2014-10-21 13:55:01.000000000 +0200
 769 +++ cups-2.0.2/scheduler/Makefile       2015-02-10 13:47:38.646396341 +0100
 770 @@ -17,6 +17,7 @@ include ../Makedefs
 771
 772  CUPSDOBJS =    \
 773                 auth.o \
 774 +               avahi.o \
 775                 banners.o \
 776                 cert.o \
 777                 classes.o \
 778 @@ -40,7 +41,8 @@ CUPSDOBJS =   \
 779                 server.o \
 780                 statbuf.o \
 781                 subscriptions.o \
 782 -               sysman.o
 783 +               sysman.o \
 784 +               timeout.o
 785  LIBOBJS =      \
 786                 filter.o \
 787                 mime.o \
 788 diff -up cups-2.0.2/scheduler/timeout.c.KUoOri cups-2.0.2/scheduler/timeout.c
 789 --- cups-2.0.2/scheduler/timeout.c.KUoOri       2015-02-10 13:47:38.646396341 +0100
 790 +++ cups-2.0.2/scheduler/timeout.c      2015-02-10 13:47:38.646396341 +0100
 791 @@ -0,0 +1,235 @@
 792 +/*
 793 + * "$Id$"
 794 + *
 795 + *   Timeout functions for the Common UNIX Printing System (CUPS).
 796 + *
 797 + *   Copyright (C) 2010, 2011 Red Hat, Inc.
 798 + *   Authors:
 799 + *     Tim Waugh <twaugh@redhat.com>
 800 + *
 801 + *   Redistribution and use in source and binary forms, with or without
 802 + *   modification, are permitted provided that the following conditions
 803 + *   are met:
 804 + *
 805 + *   Redistributions of source code must retain the above copyright
 806 + *   notice, this list of conditions and the following disclaimer.
 807 + *
 808 + *   Redistributions in binary form must reproduce the above copyright
 809 + *   notice, this list of conditions and the following disclaimer in the
 810 + *   documentation and/or other materials provided with the distribution.
 811 + *
 812 + *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 813 + *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 814 + *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 815 + *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 816 + *   COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 817 + *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 818 + *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 819 + *   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 820 + *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 821 + *   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 822 + *   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 823 + *   OF THE POSSIBILITY OF SUCH DAMAGE.
 824 + *
 825 + * Contents:
 826 + *
 827 + *   cupsdInitTimeouts()  - Initialise timeout structure.
 828 + *   cupsdAddTimeout()    - Add a timed callback.
 829 + *   cupsdNextTimeout()   - Find the next enabled timed callback.
 830 + *   cupsdUpdateTimeout() - Adjust the time of a timed callback or disable it.
 831 + *   cupsdRemoveTimeout() - Discard a timed callback.
 832 + *   compare_timeouts()   - Compare timed callbacks for array sorting.
 833 + */
 834 +
 835 +#include <config.h>
 836 +
 837 +#ifdef HAVE_AVAHI /* Applies to entire file... */
 838 +
 839 +/*
 840 + * Include necessary headers...
 841 + */
 842 +
 843 +#include "cupsd.h"
 844 +
 845 +#if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO)
 846 +#  include <malloc.h>
 847 +#endif /* HAVE_MALLOC_H && HAVE_MALLINFO */
 848 +
 849 +#ifdef HAVE_AVAHI
 850 +#  include <avahi-common/timeval.h>
 851 +#endif /* HAVE_AVAHI */
 852 +
 853 +
 854 +struct _cupsd_timeout_s
 855 +{
 856 +  struct timeval when;
 857 +  int enabled;
 858 +  cupsd_timeoutfunc_t callback;
 859 +  void *data;
 860 +};
 861 +
 862 +/*
 863 + * Local functions...
 864 + */
 865 +
 866 +/*
 867 + * 'compare_timeouts()' - Compare timed callbacks for array sorting.
 868 + */
 869 +
 870 +static int
 871 +compare_addrs (void *p0, void *p1)
 872 +{
 873 +  if (p0 == p1)
 874 +    return (0);
 875 +  if (p0 < p1)
 876 +    return (-1);
 877 +  return (1);
 878 +}
 879 +
 880 +static int
 881 +compare_timeouts (cupsd_timeout_t *p0, cupsd_timeout_t *p1)
 882 +{
 883 +  int addrsdiff = compare_addrs (p0, p1);
 884 +  int tvdiff;
 885 +
 886 +  if (addrsdiff == 0)
 887 +    return (0);
 888 +
 889 +  if (!p0->enabled || !p1->enabled)
 890 +  {
 891 +    if (!p0->enabled && !p1->enabled)
 892 +      return (addrsdiff);
 893 +
 894 +    return (p0->enabled ? -1 : 1);
 895 +  }
 896 +
 897 +  tvdiff = avahi_timeval_compare (&p0->when, &p1->when);
 898 +  if (tvdiff != 0)
 899 +    return (tvdiff);
 900 +
 901 +  return (addrsdiff);
 902 +}
 903 +
 904 +
 905 +/*
 906 + * 'cupsdInitTimeouts()' - Initialise timeout structures.
 907 + */
 908 +
 909 +void
 910 +cupsdInitTimeouts(void)
 911 +{
 912 +  Timeouts = cupsArrayNew ((cups_array_func_t)compare_timeouts, NULL);
 913 +}
 914 +
 915 +
 916 +/*
 917 + * 'cupsdAddTimeout()' - Add a timed callback.
 918 + */
 919 +
 920 +cupsd_timeout_t *                              /* O - Timeout handle */
 921 +cupsdAddTimeout(const struct timeval *tv,      /* I - Absolute time */
 922 +               cupsd_timeoutfunc_t cb,         /* I - Callback function */
 923 +               void *data)                     /* I - User data */
 924 +{
 925 +  cupsd_timeout_t *timeout;
 926 +
 927 +  timeout = malloc (sizeof(cupsd_timeout_t));
 928 +  if (timeout != NULL)
 929 +  {
 930 +    timeout->enabled = (tv != NULL);
 931 +    if (tv)
 932 +    {
 933 +      timeout->when.tv_sec = tv->tv_sec;
 934 +      timeout->when.tv_usec = tv->tv_usec;
 935 +    }
 936 +
 937 +    timeout->callback = cb;
 938 +    timeout->data = data;
 939 +    cupsArrayAdd (Timeouts, timeout);
 940 +  }
 941 +
 942 +  return timeout;
 943 +}
 944 +
 945 +
 946 +/*
 947 + * 'cupsdNextTimeout()' - Find the next enabled timed callback.
 948 + */
 949 +
 950 +cupsd_timeout_t *              /* O - Next enabled timeout or NULL */
 951 +cupsdNextTimeout(long *delay)  /* O - Seconds before scheduled */
 952 +{
 953 +  cupsd_timeout_t *first = cupsArrayFirst (Timeouts);
 954 +  struct timeval curtime;
 955 +
 956 +  if (first && !first->enabled)
 957 +    first = NULL;
 958 +
 959 +  if (first && delay)
 960 +  {
 961 +    gettimeofday (&curtime, NULL);
 962 +    if (avahi_timeval_compare (&curtime, &first->when) > 0)
 963 +    {
 964 +      *delay = 0;
 965 +    } else {
 966 +      *delay = 1 + first->when.tv_sec - curtime.tv_sec;
 967 +      if (first->when.tv_usec < curtime.tv_usec)
 968 +       (*delay)--;
 969 +    }
 970 +  }
 971 +
 972 +  return (first);
 973 +}
 974 +
 975 +
 976 +/*
 977 + * 'cupsdRunTimeout()' - Run a timed callback.
 978 + */
 979 +
 980 +void
 981 +cupsdRunTimeout(cupsd_timeout_t *timeout)      /* I - Timeout */
 982 +{
 983 +  if (!timeout)
 984 +    return;
 985 +  timeout->enabled = 0;
 986 +  if (!timeout->callback)
 987 +    return;
 988 +  timeout->callback (timeout, timeout->data);
 989 +}
 990 +
 991 +/*
 992 + * 'cupsdUpdateTimeout()' - Adjust the time of a timed callback or disable it.
 993 + */
 994 +
 995 +void
 996 +cupsdUpdateTimeout(cupsd_timeout_t *timeout,   /* I - Timeout */
 997 +                  const struct timeval *tv)    /* I - Absolute time or NULL */
 998 +{
 999 +  cupsArrayRemove (Timeouts, timeout);
1000 +  timeout->enabled = (tv != NULL);
1001 +  if (tv)
1002 +  {
1003 +    timeout->when.tv_sec = tv->tv_sec;
1004 +    timeout->when.tv_usec = tv->tv_usec;
1005 +  }
1006 +  cupsArrayAdd (Timeouts, timeout);
1007 +}
1008 +
1009 +
1010 +/*
1011 + * 'cupsdRemoveTimeout()' - Discard a timed callback.
1012 + */
1013 +
1014 +void
1015 +cupsdRemoveTimeout(cupsd_timeout_t *timeout)   /* I - Timeout */
1016 +{
1017 +  cupsArrayRemove (Timeouts, timeout);
1018 +  free (timeout);
1019 +}
1020 +
1021 +
1022 +#endif /* HAVE_AVAHI ... from top of file */
1023 +
1024 +/*
1025 + * End of "$Id$".
1026 + */