/*

 * DNS-SD discovery backend for CUPS.

 *

 * Copyright 2008-2017 by Apple Inc.

 *

 * These coded instructions, statements, and computer programs are the

 * property of Apple Inc. and are protected by Federal copyright

 * law.  Distribution and use rights are outlined in the file "LICENSE.txt"

 * "LICENSE" which should have been included with this file.  If this

 * file is missing or damaged, see the license at "http://www.cups.org/".

 *

 * This file is subject to the Apple OS-Developed Software exception.

 */

/*

 * Include necessary headers.

 */

#include "backend-private.h"

#include <cups/array.h>

#ifdef HAVE_DNSSD

#  include <dns_sd.h>

#endif /* HAVE_DNSSD */

#ifdef HAVE_AVAHI

#  include <avahi-client/client.h>

#  include <avahi-client/lookup.h>

#  include <avahi-common/simple-watch.h>

#  include <avahi-common/domain.h>

#  include <avahi-common/error.h>

#  include <avahi-common/malloc.h>

#define kDNSServiceMaxDomainName AVAHI_DOMAIN_NAME_MAX

#endif /* HAVE_AVAHI */

/*

 * Device structure...

 */

typedef enum

{

  CUPS_DEVICE_PRINTER = 0,		/* lpd://... */

  CUPS_DEVICE_IPPS,			/* ipps://... */

  CUPS_DEVICE_IPP,			/* ipp://... */

  CUPS_DEVICE_FAX_IPP,			/* ipp://... */

  CUPS_DEVICE_PDL_DATASTREAM,		/* socket://... */

  CUPS_DEVICE_RIOUSBPRINT		/* riousbprint://... */

} cups_devtype_t;

typedef struct

{

#ifdef HAVE_DNSSD

  DNSServiceRef	ref;			/* Service reference for query */

#endif /* HAVE_DNSSD */

#ifdef HAVE_AVAHI

  AvahiRecordBrowser *ref;		/* Browser for query */

#endif /* HAVE_AVAHI */

  char		*name,			/* Service name */

		*domain,		/* Domain name */

		*fullName,		/* Full name */

		*make_and_model,	/* Make and model from TXT record */

		*device_id,		/* 1284 device ID from TXT record */

		*uuid;			/* UUID from TXT record */

  cups_devtype_t type;			/* Device registration type */

  int		priority,		/* Priority associated with type */

		cups_shared,		/* CUPS shared printer? */

		sent;			/* Did we list the device? */

} cups_device_t;

/*

 * Local globals...

 */

static int		job_canceled = 0;

					/* Set to 1 on SIGTERM */

#ifdef HAVE_AVAHI

static AvahiSimplePoll	*simple_poll = NULL;

					/* Poll information */

static int		got_data = 0;	/* Got data from poll? */

static int		browsers = 0;	/* Number of running browsers */

#endif /* HAVE_AVAHI */

/*

 * Local functions...

 */

#ifdef HAVE_DNSSD

static void		browse_callback(DNSServiceRef sdRef,

			                DNSServiceFlags flags,

				        uint32_t interfaceIndex,

				        DNSServiceErrorType errorCode,

				        const char *serviceName,

				        const char *regtype,

				        const char *replyDomain, void *context)

					__attribute__((nonnull(1,5,6,7,8)));

static void		browse_local_callback(DNSServiceRef sdRef,

					      DNSServiceFlags flags,

					      uint32_t interfaceIndex,

					      DNSServiceErrorType errorCode,

					      const char *serviceName,

					      const char *regtype,

					      const char *replyDomain,

					      void *context)

					      __attribute__((nonnull(1,5,6,7,8)));

#endif /* HAVE_DNSSD */

#ifdef HAVE_AVAHI

static void		browse_callback(AvahiServiceBrowser *browser,

					AvahiIfIndex interface,

					AvahiProtocol protocol,

					AvahiBrowserEvent event,

					const char *serviceName,

					const char *regtype,

					const char *replyDomain,

					AvahiLookupResultFlags flags,

					void *context);

static void		client_callback(AvahiClient *client,

					AvahiClientState state,

					void *context);

#endif /* HAVE_AVAHI */

static int		compare_devices(cups_device_t *a, cups_device_t *b);

static void		exec_backend(char **argv) __attribute__((noreturn));

static cups_device_t	*get_device(cups_array_t *devices,

			            const char *serviceName,

			            const char *regtype,

				    const char *replyDomain)

				    __attribute__((nonnull(1,2,3,4)));

#ifdef HAVE_DNSSD

static void		query_callback(DNSServiceRef sdRef,

			               DNSServiceFlags flags,

				       uint32_t interfaceIndex,

				       DNSServiceErrorType errorCode,

				       const char *fullName, uint16_t rrtype,

				       uint16_t rrclass, uint16_t rdlen,

				       const void *rdata, uint32_t ttl,

				       void *context)

				       __attribute__((nonnull(1,5,9,11)));

#elif defined(HAVE_AVAHI)

static int		poll_callback(struct pollfd *pollfds,

			              unsigned int num_pollfds, int timeout,

			              void *context);

static void		query_callback(AvahiRecordBrowser *browser,

				       AvahiIfIndex interface,

				       AvahiProtocol protocol,

				       AvahiBrowserEvent event,

				       const char *name, uint16_t rrclass,

				       uint16_t rrtype, const void *rdata,

				       size_t rdlen,

				       AvahiLookupResultFlags flags,

				       void *context);

#endif /* HAVE_DNSSD */

static void		sigterm_handler(int sig);

static void		unquote(char *dst, const char *src, size_t dstsize)

			    __attribute__((nonnull(1,2)));

/*

 * 'main()' - Browse for printers.

 */

int					/* O - Exit status */

main(int  argc,				/* I - Number of command-line args */

     char *argv[])			/* I - Command-line arguments */

{

  const char	*name;			/* Backend name */

  cups_array_t	*devices;		/* Device array */

  cups_device_t	*device;		/* Current device */

  char		uriName[1024];		/* Unquoted fullName for URI */

#ifdef HAVE_DNSSD

  int		fd;			/* Main file descriptor */

  fd_set	input;			/* Input set for select() */

  struct timeval timeout;		/* Timeout for select() */

  DNSServiceRef	main_ref,		/* Main service reference */

		fax_ipp_ref,		/* IPP fax service reference */

		ipp_ref,		/* IPP service reference */

		ipp_tls_ref,		/* IPP w/TLS service reference */

		ipps_ref,		/* IPP service reference */

		local_fax_ipp_ref,	/* Local IPP fax service reference */

		local_ipp_ref,		/* Local IPP service reference */

		local_ipp_tls_ref,	/* Local IPP w/TLS service reference */

		local_ipps_ref,		/* Local IPP service reference */

		local_printer_ref,	/* Local LPD service reference */

		pdl_datastream_ref,	/* AppSocket service reference */

		printer_ref,		/* LPD service reference */

		riousbprint_ref;	/* Remote IO service reference */

#endif /* HAVE_DNSSD */

#ifdef HAVE_AVAHI

  AvahiClient	*client;		/* Client information */

  int		error;			/* Error code, if any */

#endif /* HAVE_AVAHI */

#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)

  struct sigaction action;		/* Actions for POSIX signals */

#endif /* HAVE_SIGACTION && !HAVE_SIGSET */

 /*

  * Don't buffer stderr, and catch SIGTERM...

  */

  setbuf(stderr, NULL);

#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */

  sigset(SIGTERM, sigterm_handler);

#elif defined(HAVE_SIGACTION)

  memset(&action, 0, sizeof(action));

  sigemptyset(&action.sa_mask);

  action.sa_handler = sigterm_handler;

  sigaction(SIGTERM, &action, NULL);

#else

  signal(SIGTERM, sigterm_handler);

#endif /* HAVE_SIGSET */

 /*

  * Check command-line...

  */

  if (argc >= 6)

    exec_backend(argv);

  else if (argc != 1)

  {

    _cupsLangPrintf(stderr,

                    _("Usage: %s job-id user title copies options [file]"),

		    argv[0]);

    return (1);

  }

 /*

  * Only do discovery when run as "dnssd"...

  */

  if ((name = strrchr(argv[0], '/')) != NULL)

    name ++;

  else

    name = argv[0];

  if (strcmp(name, "dnssd"))

    return (0);

 /*

  * Create an array to track devices...

  */

  devices = cupsArrayNew((cups_array_func_t)compare_devices, NULL);

 /*

  * Browse for different kinds of printers...

  */

#ifdef HAVE_DNSSD

  if (DNSServiceCreateConnection(&main_ref) != kDNSServiceErr_NoError)

  {

    perror("ERROR: Unable to create service connection");

    return (1);

  }

  fd = DNSServiceRefSockFD(main_ref);

  fax_ipp_ref = main_ref;

  DNSServiceBrowse(&fax_ipp_ref, kDNSServiceFlagsShareConnection, 0,

                   "_fax-ipp._tcp", NULL, browse_callback, devices);

  ipp_ref = main_ref;

  DNSServiceBrowse(&ipp_ref, kDNSServiceFlagsShareConnection, 0,

                   "_ipp._tcp", NULL, browse_callback, devices);

  ipp_tls_ref = main_ref;

  DNSServiceBrowse(&ipp_tls_ref, kDNSServiceFlagsShareConnection, 0,

                   "_ipp-tls._tcp", NULL, browse_callback, devices);

  ipps_ref = main_ref;

  DNSServiceBrowse(&ipps_ref, kDNSServiceFlagsShareConnection, 0,

                   "_ipps._tcp", NULL, browse_callback, devices);

  local_fax_ipp_ref = main_ref;

  DNSServiceBrowse(&local_fax_ipp_ref, kDNSServiceFlagsShareConnection,

                   kDNSServiceInterfaceIndexLocalOnly,

		   "_fax-ipp._tcp", NULL, browse_local_callback, devices);

  local_ipp_ref = main_ref;

  DNSServiceBrowse(&local_ipp_ref, kDNSServiceFlagsShareConnection,

                   kDNSServiceInterfaceIndexLocalOnly,

		   "_ipp._tcp", NULL, browse_local_callback, devices);

  local_ipp_tls_ref = main_ref;

  DNSServiceBrowse(&local_ipp_tls_ref, kDNSServiceFlagsShareConnection,

                   kDNSServiceInterfaceIndexLocalOnly,

                   "_ipp-tls._tcp", NULL, browse_local_callback, devices);

  local_ipps_ref = main_ref;

  DNSServiceBrowse(&local_ipps_ref, kDNSServiceFlagsShareConnection,

                   kDNSServiceInterfaceIndexLocalOnly,

		   "_ipps._tcp", NULL, browse_local_callback, devices);

  local_printer_ref = main_ref;

  DNSServiceBrowse(&local_printer_ref, kDNSServiceFlagsShareConnection,

                   kDNSServiceInterfaceIndexLocalOnly,

                   "_printer._tcp", NULL, browse_local_callback, devices);

  pdl_datastream_ref = main_ref;

  DNSServiceBrowse(&pdl_datastream_ref, kDNSServiceFlagsShareConnection, 0,

                   "_pdl-datastream._tcp", NULL, browse_callback, devices);

  printer_ref = main_ref;

  DNSServiceBrowse(&printer_ref, kDNSServiceFlagsShareConnection, 0,

                   "_printer._tcp", NULL, browse_callback, devices);

  riousbprint_ref = main_ref;

  DNSServiceBrowse(&riousbprint_ref, kDNSServiceFlagsShareConnection, 0,

                   "_riousbprint._tcp", NULL, browse_callback, devices);

#endif /* HAVE_DNSSD */

#ifdef HAVE_AVAHI

  if ((simple_poll = avahi_simple_poll_new()) == NULL)

  {

    fputs("DEBUG: Unable to create Avahi simple poll object.\n", stderr);

    return (0);

  }

  avahi_simple_poll_set_func(simple_poll, poll_callback, NULL);

  client = avahi_client_new(avahi_simple_poll_get(simple_poll),

			    0, client_callback, simple_poll, &error);

  if (!client)

  {

    fputs("DEBUG: Unable to create Avahi client.\n", stderr);

    return (0);

  }

  browsers = 6;

  avahi_service_browser_new(client, AVAHI_IF_UNSPEC,

			    AVAHI_PROTO_UNSPEC,

			    "_fax-ipp._tcp", NULL, 0,

			    browse_callback, devices);

  avahi_service_browser_new(client, AVAHI_IF_UNSPEC,

			    AVAHI_PROTO_UNSPEC,

			    "_ipp._tcp", NULL, 0,

			    browse_callback, devices);

  avahi_service_browser_new(client, AVAHI_IF_UNSPEC,

			    AVAHI_PROTO_UNSPEC,

			    "_ipp-tls._tcp", NULL, 0,

			    browse_callback, devices);

  avahi_service_browser_new(client, AVAHI_IF_UNSPEC,

			    AVAHI_PROTO_UNSPEC,

			    "_ipps._tcp", NULL, 0,

			    browse_callback, devices);

  avahi_service_browser_new(client, AVAHI_IF_UNSPEC,

			    AVAHI_PROTO_UNSPEC,

			    "_pdl-datastream._tcp",

			    NULL, 0,

			    browse_callback,

			    devices);

  avahi_service_browser_new(client, AVAHI_IF_UNSPEC,

			    AVAHI_PROTO_UNSPEC,

			    "_printer._tcp", NULL, 0,

			    browse_callback, devices);

#endif /* HAVE_AVAHI */

 /*

  * Loop until we are killed...

  */

  while (!job_canceled)

  {

    int announce = 0;			/* Announce printers? */

#ifdef HAVE_DNSSD

    FD_ZERO(&input);

    FD_SET(fd, &input);

    timeout.tv_sec  = 0;

    timeout.tv_usec = 500000;

    if (select(fd + 1, &input, NULL, NULL, &timeout) < 0)

      continue;

    if (FD_ISSET(fd, &input))

    {

     /*

      * Process results of our browsing...

      */

      DNSServiceProcessResult(main_ref);

    }

    else

      announce = 1;

#elif defined(HAVE_AVAHI)

    got_data = 0;

    if ((error = avahi_simple_poll_iterate(simple_poll, 500)) > 0)

    {

     /*

      * We've been told to exit the loop.  Perhaps the connection to

      * Avahi failed.

      */

      break;

    }

    if (!got_data)

      announce = 1;

#endif /* HAVE_DNSSD */

/*    fprintf(stderr, "DEBUG: announce=%d\n", announce);*/

    if (announce)

    {

     /*

      * Announce any devices we've found...

      */

#ifdef HAVE_DNSSD

      DNSServiceErrorType status;	/* DNS query status */

#endif /* HAVE_DNSSD */

      cups_device_t *best;		/* Best matching device */

      char	device_uri[1024];	/* Device URI */

      int	count;			/* Number of queries */

      int	sent;			/* Number of sent */

      for (device = (cups_device_t *)cupsArrayFirst(devices),

               best = NULL, count = 0, sent = 0;

           device;

	   device = (cups_device_t *)cupsArrayNext(devices))

      {

        if (device->sent)

	  sent ++;

        if (device->ref)

	  count ++;

        if (!device->ref && !device->sent)

	{

	 /*

	  * Found the device, now get the TXT record(s) for it...

	  */

          if (count < 50)

	  {

	    fprintf(stderr, "DEBUG: Querying \"%s\"...\n", device->fullName);

#ifdef HAVE_DNSSD

	    device->ref = main_ref;

	    status = DNSServiceQueryRecord(&(device->ref),

				           kDNSServiceFlagsShareConnection,

				           0, device->fullName,

					   kDNSServiceType_TXT,

				           kDNSServiceClass_IN, query_callback,

				           device);

            if (status != kDNSServiceErr_NoError)

	      fprintf(stderr,

	              "ERROR: Unable to query \"%s\" for TXT records: %d\n",

	              device->fullName, status);

	              			/* Users never see this */

	    else

	      count ++;

#else

	    if ((device->ref = avahi_record_browser_new(client, AVAHI_IF_UNSPEC,

	                                                AVAHI_PROTO_UNSPEC,

	                                                device->fullName,

	                                                AVAHI_DNS_CLASS_IN,

	                                                AVAHI_DNS_TYPE_TXT,

	                                                0,

				                        query_callback,

				                        device)) == NULL)

	      fprintf(stderr,

	              "ERROR: Unable to query \"%s\" for TXT records: %s\n",

	              device->fullName,

	              avahi_strerror(avahi_client_errno(client)));

	              			/* Users never see this */

	    else

	      count ++;

#endif /* HAVE_AVAHI */

          }

	}

	else if (!device->sent)

	{

#ifdef HAVE_DNSSD

	 /*

	  * Got the TXT records, now report the device...

	  */

	  DNSServiceRefDeallocate(device->ref);

#else

          avahi_record_browser_free(device->ref);

#endif /* HAVE_DNSSD */

	  device->ref = NULL;

          if (!best)

	    best = device;

	  else if (_cups_strcasecmp(best->name, device->name) ||

	           _cups_strcasecmp(best->domain, device->domain))

          {

	    unquote(uriName, best->fullName, sizeof(uriName));

            if (best->uuid)

	      httpAssembleURIf(HTTP_URI_CODING_ALL, device_uri,

	                       sizeof(device_uri), "dnssd", NULL, uriName, 0,

			       best->cups_shared ? "/cups?uuid=%s" : "/?uuid=%s",

			       best->uuid);

	    else

	      httpAssembleURI(HTTP_URI_CODING_ALL, device_uri,

	                      sizeof(device_uri), "dnssd", NULL, uriName, 0,

			      best->cups_shared ? "/cups" : "/");

	    cupsBackendReport("network", device_uri, best->make_and_model,

	                      best->name, best->device_id, NULL);

	    best->sent = 1;

	    best       = device;

	    sent ++;

	  }

	  else if (best->priority > device->priority ||

	           (best->priority == device->priority &&

		    best->type < device->type))

          {

	    best->sent = 1;

	    best       = device;

	    sent ++;

	  }

	  else

	  {

	    device->sent = 1;

	    sent ++;

	  }

        }

      }

      if (best)

      {

	unquote(uriName, best->fullName, sizeof(uriName));

	if (best->uuid)

	  httpAssembleURIf(HTTP_URI_CODING_ALL, device_uri,

			   sizeof(device_uri), "dnssd", NULL, uriName, 0,

			   best->cups_shared ? "/cups?uuid=%s" : "/?uuid=%s",

			   best->uuid);

	else

	  httpAssembleURI(HTTP_URI_CODING_ALL, device_uri,

			  sizeof(device_uri), "dnssd", NULL, uriName, 0,

			  best->cups_shared ? "/cups" : "/");

	cupsBackendReport("network", device_uri, best->make_and_model,

			  best->name, best->device_id, NULL);

	best->sent = 1;

	sent ++;

      }

      fprintf(stderr, "DEBUG: sent=%d, count=%d\n", sent, count);

#ifdef HAVE_AVAHI

      if (sent == cupsArrayCount(devices) && browsers == 0)

#else

      if (sent == cupsArrayCount(devices))

#endif /* HAVE_AVAHI */

	break;

    }

  }

  return (CUPS_BACKEND_OK);

}

#ifdef HAVE_DNSSD

/*

 * 'browse_callback()' - Browse devices.

 */

static void

browse_callback(

    DNSServiceRef       sdRef,		/* I - Service reference */

    DNSServiceFlags     flags,		/* I - Option flags */

    uint32_t            interfaceIndex,	/* I - Interface number */

    DNSServiceErrorType errorCode,	/* I - Error, if any */

    const char          *serviceName,	/* I - Name of service/device */

    const char          *regtype,	/* I - Type of service */

    const char          *replyDomain,	/* I - Service domain */

    void                *context)	/* I - Devices array */

{

  fprintf(stderr, "DEBUG2: browse_callback(sdRef=%p, flags=%x, "

                  "interfaceIndex=%d, errorCode=%d, serviceName=\"%s\", "

		  "regtype=\"%s\", replyDomain=\"%s\", context=%p)\n",

          sdRef, flags, interfaceIndex, errorCode,

	  serviceName, regtype, replyDomain, context);

 /*

  * Only process "add" data...

  */

  if (errorCode != kDNSServiceErr_NoError || !(flags & kDNSServiceFlagsAdd))

    return;

 /*

  * Get the device...

  */

  get_device((cups_array_t *)context, serviceName, regtype, replyDomain);

}

/*

 * 'browse_local_callback()' - Browse local devices.

 */

static void

browse_local_callback(

    DNSServiceRef       sdRef,		/* I - Service reference */

    DNSServiceFlags     flags,		/* I - Option flags */

    uint32_t            interfaceIndex,	/* I - Interface number */

    DNSServiceErrorType errorCode,	/* I - Error, if any */

    const char          *serviceName,	/* I - Name of service/device */

    const char          *regtype,	/* I - Type of service */

    const char          *replyDomain,	/* I - Service domain */

    void                *context)	/* I - Devices array */

{

  cups_device_t	*device;		/* Device */

  fprintf(stderr, "DEBUG2: browse_local_callback(sdRef=%p, flags=%x, "

                  "interfaceIndex=%d, errorCode=%d, serviceName=\"%s\", "

		  "regtype=\"%s\", replyDomain=\"%s\", context=%p)\n",

          sdRef, flags, interfaceIndex, errorCode,

	  serviceName, regtype, replyDomain, context);

 /*

  * Only process "add" data...

  */

  if (errorCode != kDNSServiceErr_NoError || !(flags & kDNSServiceFlagsAdd))

    return;

 /*

  * Get the device...

  */

  device = get_device((cups_array_t *)context, serviceName, regtype,

                      replyDomain);

 /*

  * Hide locally-registered devices...

  */

  fprintf(stderr, "DEBUG: Hiding local printer \"%s\"...\n",

	  device->fullName);

  device->sent = 1;

}

#endif /* HAVE_DNSSD */

#ifdef HAVE_AVAHI

/*

 * 'browse_callback()' - Browse devices.

 */

static void

browse_callback(

    AvahiServiceBrowser    *browser,	/* I - Browser */

    AvahiIfIndex           interface,	/* I - Interface index (unused) */

    AvahiProtocol          protocol,	/* I - Network protocol (unused) */

    AvahiBrowserEvent      event,	/* I - What happened */

    const char             *name,	/* I - Service name */

    const char             *type,	/* I - Registration type */

    const char             *domain,	/* I - Domain */

    AvahiLookupResultFlags flags,	/* I - Flags */

    void                   *context)	/* I - Devices array */

{

  AvahiClient *client = avahi_service_browser_get_client(browser);

					/* Client information */

  (void)interface;

  (void)protocol;

  (void)context;

  switch (event)

  {

    case AVAHI_BROWSER_FAILURE:

	fprintf(stderr, "DEBUG: browse_callback: %s\n",

		avahi_strerror(avahi_client_errno(client)));

	avahi_simple_poll_quit(simple_poll);

	break;

    case AVAHI_BROWSER_NEW:

       /*

	* This object is new on the network.

	*/

	if (flags & AVAHI_LOOKUP_RESULT_LOCAL)

	{

	 /*

	  * This comes from the local machine so ignore it.

	  */

	  fprintf(stderr, "DEBUG: Ignoring local service %s.\n", name);

	}

	else

	{

	 /*

	  * Create a device entry for it if it doesn't yet exist.

	  */

	  get_device((cups_array_t *)context, name, type, domain);

	}

	break;

    case AVAHI_BROWSER_REMOVE:

    case AVAHI_BROWSER_CACHE_EXHAUSTED:

        break;

    case AVAHI_BROWSER_ALL_FOR_NOW:

	browsers--;

	break;

  }

}

/*

 * 'client_callback()' - Avahi client callback function.

 */

static void

client_callback(

    AvahiClient      *client,		/* I - Client information (unused) */

    AvahiClientState state,		/* I - Current state */

    void             *context)		/* I - User data (unused) */

{

  (void)client;

  (void)context;

 /*

  * If the connection drops, quit.

  */

  if (state == AVAHI_CLIENT_FAILURE)

  {

    fputs("DEBUG: Avahi connection failed.\n", stderr);

    avahi_simple_poll_quit(simple_poll);

  }

}

#endif /* HAVE_AVAHI */

/*

 * 'compare_devices()' - Compare two devices.

 */

static int				/* O - Result of comparison */

compare_devices(cups_device_t *a,	/* I - First device */

                cups_device_t *b)	/* I - Second device */

{

  return (strcmp(a->name, b->name));

}

/*

 * 'exec_backend()' - Execute the backend that corresponds to the

 *                    resolved service name.

 */

static void

exec_backend(char **argv)		/* I - Command-line arguments */

{

  const char	*resolved_uri,		/* Resolved device URI */

		*cups_serverbin;	/* Location of programs */

  char		scheme[1024],		/* Scheme from URI */

		*ptr,			/* Pointer into scheme */

		filename[1024];		/* Backend filename */

 /*

  * Resolve the device URI...

  */

  job_canceled = -1;

  while ((resolved_uri = cupsBackendDeviceURI(argv)) == NULL)

  {

    _cupsLangPrintFilter(stderr, "INFO", _("Unable to locate printer."));

    sleep(10);

    if (getenv("CLASS") != NULL)

      exit(CUPS_BACKEND_FAILED);

  }

 /*

  * Extract the scheme from the URI...

  */

  strlcpy(scheme, resolved_uri, sizeof(scheme));

  if ((ptr = strchr(scheme, ':')) != NULL)

    *ptr = '\0';

 /*

  * Get the filename of the backend...

  */

  if ((cups_serverbin = getenv("CUPS_SERVERBIN")) == NULL)

    cups_serverbin = CUPS_SERVERBIN;

  snprintf(filename, sizeof(filename), "%s/backend/%s", cups_serverbin, scheme);

 /*

  * Overwrite the device URI and run the new backend...

  */

  setenv("DEVICE_URI", resolved_uri, 1);

  argv[0] = (char *)resolved_uri;

  fprintf(stderr, "DEBUG: Executing backend \"%s\"...\n", filename);

  execv(filename, argv);

  fprintf(stderr, "ERROR: Unable to execute backend \"%s\": %s\n", filename,

          strerror(errno));

  exit(CUPS_BACKEND_STOP);

}

/*

 * 'device_type()' - Get DNS-SD type enumeration from string.

 */

static cups_devtype_t			/* O - Device type */

device_type(const char *regtype)	/* I - Service registration type */

{

#ifdef HAVE_AVAHI

  if (!strcmp(regtype, "_ipp._tcp"))

    return (CUPS_DEVICE_IPP);

  else if (!strcmp(regtype, "_ipps._tcp") ||

	   !strcmp(regtype, "_ipp-tls._tcp"))

    return (CUPS_DEVICE_IPPS);

  else if (!strcmp(regtype, "_fax-ipp._tcp"))

    return (CUPS_DEVICE_FAX_IPP);

  else if (!strcmp(regtype, "_printer._tcp"))

    return (CUPS_DEVICE_PDL_DATASTREAM);

#else

  if (!strcmp(regtype, "_ipp._tcp."))

    return (CUPS_DEVICE_IPP);

  else if (!strcmp(regtype, "_ipps._tcp.") ||

	   !strcmp(regtype, "_ipp-tls._tcp."))

    return (CUPS_DEVICE_IPPS);

  else if (!strcmp(regtype, "_fax-ipp._tcp."))

    return (CUPS_DEVICE_FAX_IPP);

  else if (!strcmp(regtype, "_printer._tcp."))

    return (CUPS_DEVICE_PRINTER);

  else if (!strcmp(regtype, "_pdl-datastream._tcp."))

    return (CUPS_DEVICE_PDL_DATASTREAM);

#endif /* HAVE_AVAHI */

  return (CUPS_DEVICE_RIOUSBPRINT);

}

/*

 * 'get_device()' - Create or update a device.

 */

static cups_device_t *			/* O - Device */

get_device(cups_array_t *devices,	/* I - Device array */

           const char   *serviceName,	/* I - Name of service/device */

           const char   *regtype,	/* I - Type of service */

           const char   *replyDomain)	/* I - Service domain */

{

  cups_device_t	key,			/* Search key */

		*device;		/* Device */

  char		fullName[kDNSServiceMaxDomainName];

					/* Full name for query */

 /*

  * See if this is a new device...

  */