cups/patches/cups-1.5.2-avahi-4-poll.patch

diff -up cups-1.5.0/scheduler/avahi.c.avahi-4-poll cups-1.5.0/scheduler/avahi.c
--- cups-1.5.0/scheduler/avahi.c.avahi-4-poll	2011-10-11 10:56:50.102288037 +0100
+++ cups-1.5.0/scheduler/avahi.c	2011-10-11 10:56:50.102288037 +0100
@@ -0,0 +1,441 @@
+/*
+ * "$Id$"
+ *
+ *   Avahi poll implementation for the CUPS scheduler.
+ *
+ *   Copyright (C) 2010, 2011 Red Hat, Inc.
+ *   Authors:
+ *    Tim Waugh <twaugh@redhat.com>
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *   Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *   COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ *   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ *   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ *   OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Contents:
+ *
+ *   watch_read_cb         - Read callback for file descriptor
+ *   watch_write_cb        - Write callback for file descriptor
+ *   watched_fd_add_select() - Call cupsdAddSelect() as needed
+ *   watch_new()           - Create a new file descriptor watch
+ *   watch_free()          - Free a file descriptor watch
+ *   watch_update()        - Update watched events for a file descriptor
+ *   watch_get_events()    - Get events that happened for a file descriptor
+ *   timeout_cb()          - Run a timed Avahi callback
+ *   timeout_new()         - Set a wakeup time
+ *   timeout_update()      - Update the expiration time for a timeout
+ *   timeout_free()        - Free a timeout
+ *   compare_watched_fds() - Compare watched file descriptors for array sorting
+ *   avahi_cups_poll_new() - Create a new Avahi main loop object for CUPS
+ *   avahi_cups_poll_free() - Free an Avahi main loop object for CUPS
+ *   avahi_cups_poll_get() - Get the abstract poll API structure
+ */
+
+#include <config.h>
+
+#ifdef HAVE_AVAHI /* Applies to entire file... */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "cupsd.h"
+
+#if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO)
+#  include <malloc.h>
+#endif /* HAVE_MALLOC_H && HAVE_MALLINFO */
+
+#ifdef HAVE_AVAHI
+#  include <avahi-common/timeval.h>
+#endif /* HAVE_AVAHI */
+
+
+typedef struct
+{
+  AvahiCupsPoll *cups_poll;
+
+  int fd;
+  AvahiWatchEvent occurred;
+  cups_array_t *watches;
+} cupsd_watched_fd_t;
+
+struct AvahiWatch
+{
+  cupsd_watched_fd_t *watched_fd;
+
+  AvahiWatchEvent events;
+  AvahiWatchCallback callback;
+  void *userdata;
+};
+
+struct AvahiTimeout
+{
+  AvahiCupsPoll *cups_poll;
+  AvahiTimeoutCallback callback;
+  void *userdata;
+  cupsd_timeout_t *cupsd_timeout;
+};
+
+/*
+ * Local functions...
+ */
+
+static AvahiWatch *	watch_new(const AvahiPoll *api,
+				  int fd,
+				  AvahiWatchEvent events,
+				  AvahiWatchCallback callback,
+				  void *userdata);
+static void		watch_free(AvahiWatch *watch);
+static void		watch_update(AvahiWatch *watch,
+				     AvahiWatchEvent events);
+static AvahiWatchEvent	watch_get_events(AvahiWatch *watch);
+
+
+/*
+ * 'watch_read_cb' - Read callback for file descriptor
+ */
+
+static void
+watch_read_cb (void *userdata)
+{
+  AvahiWatch *watch;
+  cupsd_watched_fd_t *watched_fd = userdata;
+  watched_fd->occurred |= AVAHI_WATCH_IN;
+  for (watch = (AvahiWatch *)cupsArrayFirst(watched_fd->watches);
+       watch;
+       watch = (AvahiWatch *)cupsArrayNext(watched_fd->watches))
+  {
+    if (watch->events & watched_fd->occurred)
+    {
+      (watch->callback) (watch, watched_fd->fd,
+			 AVAHI_WATCH_IN, watch->userdata);
+      watched_fd->occurred &= ~AVAHI_WATCH_IN;
+      break;
+    }
+  }
+}
+
+
+/*
+ * 'watch_write_cb' - Write callback for file descriptor
+ */
+
+static void
+watch_write_cb (void *userdata)
+{
+  AvahiWatch *watch;
+  cupsd_watched_fd_t *watched_fd = userdata;
+  watched_fd->occurred |= AVAHI_WATCH_OUT;
+  for (watch = (AvahiWatch *)cupsArrayFirst(watched_fd->watches);
+       watch;
+       watch = (AvahiWatch *)cupsArrayNext(watched_fd->watches))
+  {
+    if (watch->events & watched_fd->occurred)
+    {
+      (watch->callback) (watch, watched_fd->fd,
+			 AVAHI_WATCH_OUT, watch->userdata);
+      watched_fd->occurred &= ~AVAHI_WATCH_OUT;
+      break;
+    }
+  }
+}
+
+
+/*
+ * 'watched_fd_add_select' - Call cupsdAddSelect() as needed
+ */
+
+static int						/* O - Watches? */
+watched_fd_add_select (cupsd_watched_fd_t *watched_fd)
+{
+  AvahiWatch *watch;
+  cupsd_selfunc_t read_cb = NULL, write_cb = NULL;
+  int any_watches = 0;
+
+  for (watch = (AvahiWatch *)cupsArrayFirst(watched_fd->watches);
+       watch;
+       watch = (AvahiWatch *)cupsArrayNext(watched_fd->watches))
+  {
+    any_watches = 1;
+    if (watch->events & (AVAHI_WATCH_IN |
+			     AVAHI_WATCH_ERR |
+			     AVAHI_WATCH_HUP))
+    {
+      read_cb = (cupsd_selfunc_t)watch_read_cb;
+      if (write_cb != NULL)
+	break;
+    }
+
+    if (watch->events & AVAHI_WATCH_OUT)
+    {
+      write_cb = (cupsd_selfunc_t)watch_write_cb;
+      if (read_cb != NULL)
+	break;
+    }
+  }
+
+  if (read_cb || write_cb)
+    cupsdAddSelect (watched_fd->fd, read_cb, write_cb, watched_fd);
+  else
+    cupsdRemoveSelect (watched_fd->fd);
+
+  return (any_watches);
+}
+
+/*
+ * 'watch_new' - Create a new file descriptor watch
+ */
+
+static AvahiWatch *
+watch_new (const AvahiPoll *api,
+	   int fd,
+	   AvahiWatchEvent events,
+	   AvahiWatchCallback callback,
+	   void *userdata)
+{
+  cupsd_watched_fd_t key, *watched_fd;
+  AvahiCupsPoll *cups_poll = api->userdata;
+  AvahiWatch *watch = malloc(sizeof(AvahiWatch));
+  if (watch == NULL)
+    return (NULL);
+
+  watch->events = events;
+  watch->callback = callback;
+  watch->userdata = userdata;
+
+  key.fd = fd;
+  watched_fd = cupsArrayFind (cups_poll->watched_fds, &key);
+  if (watched_fd == NULL)
+  {
+    watched_fd = malloc(sizeof(cupsd_watched_fd_t));
+    if (watched_fd == NULL)
+    {
+      free (watch);
+      return (NULL);
+    }
+
+    watched_fd->fd = fd;
+    watched_fd->occurred = 0;
+    watched_fd->cups_poll = cups_poll;
+    watched_fd->watches = cupsArrayNew (NULL, NULL);
+    cupsArrayAdd (cups_poll->watched_fds, watched_fd);
+  }
+
+  watch->watched_fd = watched_fd;
+  cupsArrayAdd(watched_fd->watches, watch);
+  watched_fd_add_select (watched_fd);
+  return (watch);
+}
+
+
+/*
+ * 'watch_free' - Free a file descriptor watch
+ */
+
+static void
+watch_free (AvahiWatch *watch)
+{
+  cupsd_watched_fd_t *watched_fd = watch->watched_fd;
+  AvahiCupsPoll *cups_poll = watched_fd->cups_poll;
+
+  cupsArrayRemove (watched_fd->watches, watch);
+  free (watch);
+
+  if (!watched_fd_add_select (watched_fd))
+  {
+    /* No more watches */
+    cupsArrayRemove (cups_poll->watched_fds, watched_fd);
+    free (watched_fd);
+  }
+}
+
+
+/*
+ * 'watch_update' - Update watched events for a file descriptor
+ */
+
+static void
+watch_update (AvahiWatch *watch,
+	      AvahiWatchEvent events)
+{
+  watch->events = events;
+  watched_fd_add_select (watch->watched_fd);
+}
+
+
+/*
+ * 'watch_get_events' - Get events that happened for a file descriptor
+ */
+
+static AvahiWatchEvent
+watch_get_events (AvahiWatch *watch)
+{
+  return (watch->watched_fd->occurred);
+}
+
+
+/*
+ * 'timeout_cb()' - Run a timed Avahi callback
+ */
+
+static void
+timeout_cb (cupsd_timeout_t *cupsd_timeout, void *userdata)
+{
+  AvahiTimeout *timeout = userdata;
+  (timeout->callback) (timeout, timeout->userdata);
+}
+
+
+/*
+ * 'timeout_new' - Set a wakeup time
+ */
+
+static AvahiTimeout *
+timeout_new (const AvahiPoll *api,
+	     const struct timeval *tv,
+	     AvahiTimeoutCallback callback,
+	     void *userdata)
+{
+  AvahiTimeout *timeout;
+  AvahiCupsPoll *cups_poll = api->userdata;
+
+  timeout = malloc(sizeof(AvahiTimeout));
+  if (timeout == NULL)
+    return (NULL);
+
+  timeout->cups_poll = cups_poll;
+  timeout->callback = callback;
+  timeout->userdata = userdata;
+  timeout->cupsd_timeout = cupsdAddTimeout (tv,
+					    (cupsd_timeoutfunc_t)timeout_cb,
+					    timeout);
+  cupsArrayAdd (cups_poll->timeouts, timeout);
+  return (timeout);
+}
+
+
+/*
+ * 'timeout_update' - Update the expiration time for a timeout
+ */
+
+static void
+timeout_update (AvahiTimeout *timeout,
+		const struct timeval *tv)
+{
+  cupsdUpdateTimeout (timeout->cupsd_timeout, tv);
+}
+
+
+/*
+ * ' timeout_free' - Free a timeout
+ */
+
+static void
+timeout_free (AvahiTimeout *timeout)
+{
+  cupsArrayRemove (timeout->cups_poll->timeouts, timeout);
+  cupsdRemoveTimeout (timeout->cupsd_timeout);
+  free (timeout);
+}
+
+
+/*
+ * 'compare_watched_fds' - Compare watched file descriptors for array sorting
+ */
+static int
+compare_watched_fds(cupsd_watched_fd_t *p0,
+		    cupsd_watched_fd_t *p1)
+{
+  /*
+   * Compare by fd (no two elements have the same fd)
+   */
+
+  if (p0->fd == p1->fd)
+    return 0;
+
+  return (p0->fd < p1->fd ? -1 : 1);
+}
+
+
+/*
+ * 'avahi_cups_poll_new' - Create a new Avahi main loop object for CUPS
+ */
+
+AvahiCupsPoll *
+avahi_cups_poll_new (void)
+{
+  AvahiCupsPoll *cups_poll = malloc(sizeof(AvahiCupsPoll));
+  if (cups_poll == NULL)
+    return (NULL);
+
+  cups_poll->watched_fds = cupsArrayNew ((cups_array_func_t)compare_watched_fds,
+					 NULL);
+  cups_poll->timeouts = cupsArrayNew (NULL, NULL);
+
+  cups_poll->api.userdata = cups_poll;
+  cups_poll->api.watch_new = watch_new;
+  cups_poll->api.watch_free = watch_free;
+  cups_poll->api.watch_update = watch_update;
+  cups_poll->api.watch_get_events = watch_get_events;
+
+  cups_poll->api.timeout_new = timeout_new;
+  cups_poll->api.timeout_update = timeout_update;
+  cups_poll->api.timeout_free = timeout_free;
+
+  return (cups_poll);
+}
+
+
+/*
+ * 'avahi_cups_poll_free' - Free an Avahi main loop object for CUPS
+ */
+void
+avahi_cups_poll_free (AvahiCupsPoll *cups_poll)
+{
+  cupsd_watched_fd_t *watched_fd;
+
+  for (watched_fd = (cupsd_watched_fd_t*)cupsArrayFirst(cups_poll->watched_fds);
+       watched_fd;
+       watched_fd = (cupsd_watched_fd_t*)cupsArrayNext(cups_poll->watched_fds))
+    cupsArrayClear (watched_fd->watches);
+
+  cupsArrayClear (cups_poll->watched_fds);
+  cupsArrayClear (cups_poll->timeouts);
+}
+
+
+/*
+ * 'avahi_cups_poll_get' - Get the abstract poll API structure
+ */
+
+const AvahiPoll *
+avahi_cups_poll_get (AvahiCupsPoll *cups_poll)
+{
+  return (&cups_poll->api);
+}
+
+
+#endif /* HAVE_AVAHI ... from top of file */
+
+/*
+ * End of "$Id$".
+ */
diff -up cups-1.5.0/scheduler/avahi.h.avahi-4-poll cups-1.5.0/scheduler/avahi.h
--- cups-1.5.0/scheduler/avahi.h.avahi-4-poll	2011-10-11 10:56:50.102288037 +0100
+++ cups-1.5.0/scheduler/avahi.h	2011-10-11 10:56:50.119287724 +0100
@@ -0,0 +1,69 @@
+/*
+ * "$Id$"
+ *
+ *   Avahi poll implementation for the CUPS scheduler.
+ *
+ *   Copyright (C) 2010, 2011 Red Hat, Inc.
+ *   Authors:
+ *    Tim Waugh <twaugh@redhat.com>
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *   Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *   COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ *   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ *   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ *   OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <config.h>
+
+#ifdef HAVE_AVAHI
+#  include <avahi-client/client.h>
+#  include <avahi-client/publish.h>
+#endif /* HAVE_AVAHI */
+
+#ifdef HAVE_AUTHORIZATION_H
+#  include <Security/Authorization.h>
+#endif /* HAVE_AUTHORIZATION_H */
+
+
+#ifdef HAVE_AVAHI
+typedef struct
+{
+    AvahiPoll api;
+    cups_array_t *watched_fds;
+    cups_array_t *timeouts;
+} AvahiCupsPoll;
+#endif /* HAVE_AVAHI */
+
+/*
+ * Prototypes...
+ */
+
+#ifdef HAVE_AVAHI
+extern AvahiCupsPoll *	avahi_cups_poll_new(void);
+extern void		avahi_cups_poll_free(AvahiCupsPoll *cups_poll);
+extern const AvahiPoll *avahi_cups_poll_get(AvahiCupsPoll *cups_poll);
+#endif /* HAVE_AVAHI */
+
+
+/*
+ * End of "$Id$".
+ */
diff -up cups-1.5.0/scheduler/Makefile.avahi-4-poll cups-1.5.0/scheduler/Makefile
--- cups-1.5.0/scheduler/Makefile.avahi-4-poll	2011-10-11 10:56:45.868365861 +0100
+++ cups-1.5.0/scheduler/Makefile	2011-10-11 10:56:50.101288055 +0100
@@ -17,6 +17,7 @@ include ../Makedefs
 
 CUPSDOBJS =	\
 		auth.o \
+		avahi.o \
 		banners.o \
 		cert.o \
 		classes.o \
1	niro	1642	diff -up cups-1.5.0/scheduler/avahi.c.avahi-4-poll cups-1.5.0/scheduler/avahi.c
2			--- cups-1.5.0/scheduler/avahi.c.avahi-4-poll 2011-10-11 10:56:50.102288037 +0100
3			+++ cups-1.5.0/scheduler/avahi.c 2011-10-11 10:56:50.102288037 +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-1.5.0/scheduler/avahi.h.avahi-4-poll cups-1.5.0/scheduler/avahi.h
447			--- cups-1.5.0/scheduler/avahi.h.avahi-4-poll 2011-10-11 10:56:50.102288037 +0100
448			+++ cups-1.5.0/scheduler/avahi.h 2011-10-11 10:56:50.119287724 +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-1.5.0/scheduler/Makefile.avahi-4-poll cups-1.5.0/scheduler/Makefile
520			--- cups-1.5.0/scheduler/Makefile.avahi-4-poll 2011-10-11 10:56:45.868365861 +0100
521			+++ cups-1.5.0/scheduler/Makefile 2011-10-11 10:56:50.101288055 +0100
522			@@ -17,6 +17,7 @@ include ../Makedefs
523
524			CUPSDOBJS = \
525			auth.o \
526			+ avahi.o \
527			banners.o \
528			cert.o \
529			classes.o \