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	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 \