/*

 * SNMP discovery backend for CUPS.

 *

 * Copyright 2007-2014 by Apple Inc.

 * Copyright 2006-2007 by Easy Software Products, all rights reserved.

 *

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

#include <cups/file.h>

#include <cups/http-private.h>

#include <regex.h>

/*

 * This backend implements SNMP printer discovery.  It uses a broadcast-

 * based approach to get SNMP response packets from potential printers,

 * requesting OIDs from the Host and Port Monitor MIBs, does a URI

 * lookup based on the device description string, and finally a probe of

 * port 9100 (AppSocket) and 515 (LPD).

 *

 * The current focus is on printers with internal network cards, although

 * the code also works with many external print servers as well.

 *

 * The backend reads the snmp.conf file from the CUPS_SERVERROOT directory

 * which can contain comments, blank lines, or any number of the following

 * directives:

 *

 *     Address ip-address

 *     Address @LOCAL

 *     Address @IF(name)

 *     Community name

 *     DebugLevel N

 *     DeviceURI "regex pattern" uri

 *     HostNameLookups on

 *     HostNameLookups off

 *     MaxRunTime N

 *

 * The default is to use:

 *

 *     Address @LOCAL

 *     Community public

 *     DebugLevel 0

 *     HostNameLookups off

 *     MaxRunTime 120

 *

 * This backend is known to work with the following network printers and

 * print servers:

 *

 *     Axis OfficeBasic, 5400, 5600

 *     Brother

 *     EPSON

 *     Genicom

 *     HP JetDirect

 *     Lexmark

 *     Sharp

 *     Tektronix

 *     Xerox

 *

 * It does not currently work with:

 *

 *     DLink

 *     Linksys

 *     Netgear

 *     Okidata

 *

 * (for all of these, they do not support the Host MIB)

 */

/*

 * Types...

 */

enum					/**** Request IDs for each field ****/

{

  DEVICE_TYPE = 1,

  DEVICE_DESCRIPTION,

  DEVICE_LOCATION,

  DEVICE_ID,

  DEVICE_URI,

  DEVICE_PRODUCT

};

typedef struct device_uri_s		/**** DeviceURI values ****/

{

  regex_t	re;			/* Regular expression to match */

  cups_array_t	*uris;			/* URIs */

} device_uri_t;

typedef struct snmp_cache_s		/**** SNMP scan cache ****/

{

  http_addr_t	address;		/* Address of device */

  char		*addrname,		/* Name of device */

		*uri,			/* device-uri */

		*id,			/* device-id */

		*info,			/* device-info */

		*location,		/* device-location */

		*make_and_model;	/* device-make-and-model */

  int		sent;			/* Has this device been listed? */

} snmp_cache_t;

/*

 * Local functions...

 */

static char		*add_array(cups_array_t *a, const char *s);

static void		add_cache(http_addr_t *addr, const char *addrname,

			          const char *uri, const char *id,

				  const char *make_and_model);

static device_uri_t	*add_device_uri(char *value);

static void		alarm_handler(int sig);

static int		compare_cache(snmp_cache_t *a, snmp_cache_t *b);

static void		debug_printf(const char *format, ...);

static void		fix_make_model(char *make_model,

			               const char *old_make_model,

				       int make_model_size);

static void		free_array(cups_array_t *a);

static void		free_cache(void);

static http_addrlist_t	*get_interface_addresses(const char *ifname);

static void		list_device(snmp_cache_t *cache);

static const char	*password_cb(const char *prompt);

static void		probe_device(snmp_cache_t *device);

static void		read_snmp_conf(const char *address);

static void		read_snmp_response(int fd);

static double		run_time(void);

static void		scan_devices(int ipv4, int ipv6);

static int		try_connect(http_addr_t *addr, const char *addrname,

			            int port);

static void		update_cache(snmp_cache_t *device, const char *uri,

			             const char *id, const char *make_model);

/*

 * Local globals...

 */

static cups_array_t	*Addresses = NULL;

static cups_array_t	*Communities = NULL;

static cups_array_t	*Devices = NULL;

static int		DebugLevel = 0;

static const int	DescriptionOID[] = { CUPS_OID_hrDeviceDescr, 1, -1 };

static const int	LocationOID[] = { CUPS_OID_sysLocation, 0, -1 };

static const int	DeviceTypeOID[] = { CUPS_OID_hrDeviceType, 1, -1 };

static const int	DeviceIdOID[] = { CUPS_OID_ppmPrinterIEEE1284DeviceId, 1, -1 };

static const int	UriOID[] = { CUPS_OID_ppmPortServiceNameOrURI, 1, 1, -1 };

static const int	LexmarkProductOID[] = { 1,3,6,1,4,1,641,2,1,2,1,2,1,-1 };

static const int	LexmarkProductOID2[] = { 1,3,6,1,4,1,674,10898,100,2,1,2,1,2,1,-1 };

static const int	LexmarkDeviceIdOID[] = { 1,3,6,1,4,1,641,2,1,2,1,3,1,-1 };

static const int	HPDeviceIdOID[] = { 1,3,6,1,4,1,11,2,3,9,1,1,7,0,-1 };

static const int	RicohDeviceIdOID[] = { 1,3,6,1,4,1,367,3,2,1,1,1,11,0,-1 };

static const int	XeroxProductOID[] = { 1,3,6,1,4,1,128,2,1,3,1,2,0,-1 };

static cups_array_t	*DeviceURIs = NULL;

static int		HostNameLookups = 0;

static int		MaxRunTime = 120;

static struct timeval	StartTime;

/*

 * 'main()' - Discover printers via SNMP.

 */

int					/* O - Exit status */

main(int  argc,				/* I - Number of command-line arguments (6 or 7) */

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

{

  int		ipv4,			/* SNMP IPv4 socket */

		ipv6;			/* SNMP IPv6 socket */

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

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

#endif /* HAVE_SIGACTION && !HAVE_SIGSET */

 /*

  * Check command-line options...

  */

  if (argc > 2)

  {

    _cupsLangPuts(stderr, _("Usage: snmp [host-or-ip-address]"));

    return (1);

  }

 /*

  * Set the password callback for IPP operations...

  */

  cupsSetPasswordCB(password_cb);

 /*

  * Catch SIGALRM signals...

  */

#ifdef HAVE_SIGSET

  sigset(SIGALRM, alarm_handler);

#elif defined(HAVE_SIGACTION)

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

  sigemptyset(&action.sa_mask);

  sigaddset(&action.sa_mask, SIGALRM);

  action.sa_handler = alarm_handler;

  sigaction(SIGALRM, &action, NULL);

#else

  signal(SIGALRM, alarm_handler);

#endif /* HAVE_SIGSET */

 /*

  * Open the SNMP socket...

  */

  if ((ipv4 = _cupsSNMPOpen(AF_INET)) < 0)

    return (1);

#ifdef AF_INET6

  if ((ipv6 = _cupsSNMPOpen(AF_INET6)) < 0)

    perror("DEBUG: Unable to create IPv6 socket");

#else

  ipv6 = -1;

#endif /* AF_INET6 */

 /*

  * Read the configuration file and any cache data...

  */

  read_snmp_conf(argv[1]);

  _cupsSNMPSetDebug(DebugLevel);

  Devices = cupsArrayNew((cups_array_func_t)compare_cache, NULL);

 /*

  * Scan for devices...

  */

  scan_devices(ipv4, ipv6);

 /*

  * Close, free, and return with no errors...

  */

  _cupsSNMPClose(ipv4);

  if (ipv6 >= 0)

    _cupsSNMPClose(ipv6);

  free_array(Addresses);

  free_array(Communities);

  free_cache();

  return (0);

}

/*

 * 'add_array()' - Add a string to an array.

 */

static char *				/* O - New string */

add_array(cups_array_t *a,		/* I - Array */

          const char   *s)		/* I - String to add */

{

  char	*dups;				/* New string */

  dups = strdup(s);

  cupsArrayAdd(a, dups);

  return (dups);

}

/*

 * 'add_cache()' - Add a cached device...

 */

static void

add_cache(http_addr_t *addr,		/* I - Device IP address */

          const char  *addrname,	/* I - IP address or name string */

          const char  *uri,		/* I - Device URI */

          const char  *id,		/* I - 1284 device ID */

	  const char  *make_and_model)	/* I - Make and model */

{

  snmp_cache_t	*temp;			/* New device entry */

  debug_printf("DEBUG: add_cache(addr=%p, addrname=\"%s\", uri=\"%s\", "

                  "id=\"%s\", make_and_model=\"%s\")\n",

               addr, addrname, uri ? uri : "(null)", id ? id : "(null)",

	       make_and_model ? make_and_model : "(null)");

  temp = calloc(1, sizeof(snmp_cache_t));

  memcpy(&(temp->address), addr, sizeof(temp->address));

  temp->addrname = strdup(addrname);

  if (uri)

    temp->uri = strdup(uri);

  if (id)

    temp->id = strdup(id);

  if (make_and_model)

    temp->make_and_model = strdup(make_and_model);

  cupsArrayAdd(Devices, temp);

  if (uri)

    list_device(temp);

}

/*

 * 'add_device_uri()' - Add a device URI to the cache.

 *

 * The value string is modified (chopped up) as needed.

 */

static device_uri_t *			/* O - Device URI */

add_device_uri(char *value)		/* I - Value from snmp.conf */

{

  device_uri_t	*device_uri;		/* Device URI */

  char		*start;			/* Start of value */

 /*

  * Allocate memory as needed...

  */

  if (!DeviceURIs)

    DeviceURIs = cupsArrayNew(NULL, NULL);

  if (!DeviceURIs)

    return (NULL);

  if ((device_uri = calloc(1, sizeof(device_uri_t))) == NULL)

    return (NULL);

  if ((device_uri->uris = cupsArrayNew(NULL, NULL)) == NULL)

  {

    free(device_uri);

    return (NULL);

  }

 /*

  * Scan the value string for the regular expression and URI(s)...

  */

  value ++; /* Skip leading " */

  for (start = value; *value && *value != '\"'; value ++)

    if (*value == '\\' && value[1])

      _cups_strcpy(value, value + 1);

  if (!*value)

  {

    fputs("ERROR: Missing end quote for DeviceURI!\n", stderr);

    cupsArrayDelete(device_uri->uris);

    free(device_uri);

    return (NULL);

  }

  *value++ = '\0';

  if (regcomp(&(device_uri->re), start, REG_EXTENDED | REG_ICASE))

  {

    fputs("ERROR: Bad regular expression for DeviceURI!\n", stderr);

    cupsArrayDelete(device_uri->uris);

    free(device_uri);

    return (NULL);

  }

  while (*value)

  {

    while (isspace(*value & 255))

      value ++;

    if (!*value)

      break;

    for (start = value; *value && !isspace(*value & 255); value ++);

    if (*value)

      *value++ = '\0';

    cupsArrayAdd(device_uri->uris, strdup(start));

  }

 /*

  * Add the device URI to the list and return it...

  */

  cupsArrayAdd(DeviceURIs, device_uri);

  return (device_uri);

}

/*

 * 'alarm_handler()' - Handle alarm signals...

 */

static void

alarm_handler(int sig)			/* I - Signal number */

{

 /*

  * Do nothing...

  */

  (void)sig;

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

  signal(SIGALRM, alarm_handler);

#endif /* !HAVE_SIGSET && !HAVE_SIGACTION */

  if (DebugLevel)

    write(2, "DEBUG: ALARM!\n", 14);

}

/*

 * 'compare_cache()' - Compare two cache entries.

 */

static int				/* O - Result of comparison */

compare_cache(snmp_cache_t *a,		/* I - First cache entry */

              snmp_cache_t *b)		/* I - Second cache entry */

{

  return (_cups_strcasecmp(a->addrname, b->addrname));

}

/*

 * 'debug_printf()' - Display some debugging information.

 */

static void

debug_printf(const char *format,	/* I - Printf-style format string */

             ...)			/* I - Additional arguments as needed */

{

  va_list	ap;			/* Pointer to arguments */

  if (!DebugLevel)

    return;

  va_start(ap, format);

  vfprintf(stderr, format, ap);

  va_end(ap);

}

/*

 * 'fix_make_model()' - Fix common problems in the make-and-model string.

 */

static void

fix_make_model(

    char       *make_model,		/* I - New make-and-model string */

    const char *old_make_model,		/* I - Old make-and-model string */

    int        make_model_size)		/* I - Size of new string buffer */

{

  char	*mmptr;				/* Pointer into make-and-model string */

 /*

  * Fix some common problems with the make-and-model string so

  * that printer driver detection works better...

  */

  if (!_cups_strncasecmp(old_make_model, "Hewlett-Packard", 15))

  {

   /*

    * Strip leading Hewlett-Packard and hp prefixes and replace

    * with a single HP manufacturer prefix...

    */

    mmptr = (char *)old_make_model + 15;

    while (isspace(*mmptr & 255))

      mmptr ++;

    if (!_cups_strncasecmp(mmptr, "hp", 2))

    {

      mmptr += 2;

      while (isspace(*mmptr & 255))

	mmptr ++;

    }

    make_model[0] = 'H';

    make_model[1] = 'P';

    make_model[2] = ' ';

    strlcpy(make_model + 3, mmptr, (size_t)make_model_size - 3);

  }

  else if (!_cups_strncasecmp(old_make_model, "deskjet", 7))

    snprintf(make_model, (size_t)make_model_size, "HP DeskJet%s", old_make_model + 7);

  else if (!_cups_strncasecmp(old_make_model, "officejet", 9))

    snprintf(make_model, (size_t)make_model_size, "HP OfficeJet%s", old_make_model + 9);

  else if (!_cups_strncasecmp(old_make_model, "stylus_pro_", 11))

    snprintf(make_model, (size_t)make_model_size, "EPSON Stylus Pro %s", old_make_model + 11);

  else

    strlcpy(make_model, old_make_model, (size_t)make_model_size);

  if ((mmptr = strstr(make_model, ", Inc.,")) != NULL)

  {

   /*

    * Strip inc. from name, e.g. "Tektronix, Inc., Phaser 560"

    * becomes "Tektronix Phaser 560"...

    */

    _cups_strcpy(mmptr, mmptr + 7);

  }

  if ((mmptr = strstr(make_model, " Network")) != NULL)

  {

   /*

    * Drop unnecessary informational text, e.g. "Xerox DocuPrint N2025

    * Network LaserJet - 2.12" becomes "Xerox DocuPrint N2025"...

    */

    *mmptr = '\0';

  }

  if ((mmptr = strchr(make_model, ',')) != NULL)

  {

   /*

    * Drop anything after a trailing comma...

    */

    *mmptr = '\0';

  }

}

/*

 * 'free_array()' - Free an array of strings.

 */

static void

free_array(cups_array_t *a)		/* I - Array */

{

  char	*s;				/* Current string */

  for (s = (char *)cupsArrayFirst(a); s; s = (char *)cupsArrayNext(a))

    free(s);

  cupsArrayDelete(a);

}

/*

 * 'free_cache()' - Free the array of cached devices.

 */

static void

free_cache(void)

{

  snmp_cache_t	*cache;			/* Cached device */

  for (cache = (snmp_cache_t *)cupsArrayFirst(Devices);

       cache;

       cache = (snmp_cache_t *)cupsArrayNext(Devices))

  {

    free(cache->addrname);

    if (cache->uri)

      free(cache->uri);

    if (cache->id)

      free(cache->id);

    if (cache->make_and_model)

      free(cache->make_and_model);

    free(cache);

  }

  cupsArrayDelete(Devices);

  Devices = NULL;

}

/*

 * 'get_interface_addresses()' - Get the broadcast address(es) associated

 *                               with an interface.

 */

static http_addrlist_t *		/* O - List of addresses */

get_interface_addresses(

    const char *ifname)			/* I - Interface name */

{

  struct ifaddrs	*addrs,		/* Interface address list */

			*addr;		/* Current interface address */

  http_addrlist_t	*first,		/* First address in list */

			*last,		/* Last address in list */

			*current;	/* Current address */

  if (getifaddrs(&addrs) < 0)

    return (NULL);

  for (addr = addrs, first = NULL, last = NULL; addr; addr = addr->ifa_next)

    if ((addr->ifa_flags & IFF_BROADCAST) && addr->ifa_broadaddr &&

        addr->ifa_broadaddr->sa_family == AF_INET &&

	(!ifname || !strcmp(ifname, addr->ifa_name)))

    {

      current = calloc(1, sizeof(http_addrlist_t));

      memcpy(&(current->addr), addr->ifa_broadaddr,

             sizeof(struct sockaddr_in));

      if (!last)

        first = current;

      else

        last->next = current;

      last = current;

    }

  freeifaddrs(addrs);

  return (first);

}

/*

 * 'list_device()' - List a device we found...

 */

static void

list_device(snmp_cache_t *cache)	/* I - Cached device */

{

  if (cache->uri)

    cupsBackendReport("network", cache->uri, cache->make_and_model,

                      cache->info, cache->id, cache->location);

}

/*

 * 'password_cb()' - Handle authentication requests.

 *

 * All we do right now is return NULL, indicating that no authentication

 * is possible.

 */

static const char *			/* O - Password (NULL) */

password_cb(const char *prompt)		/* I - Prompt message */

{

  (void)prompt;				/* Anti-compiler-warning-code */

  return (NULL);

}

/*

 * 'probe_device()' - Probe a device to discover whether it is a printer.

 *

 * TODO: Try using the Port Monitor MIB to discover the correct protocol

 *       to use - first need a commercially-available printer that supports

 *       it, though...

 */

static void

probe_device(snmp_cache_t *device)	/* I - Device */

{

  char		uri[1024],		/* Full device URI */

		*uriptr,		/* Pointer into URI */

		*format;		/* Format string for device */

  device_uri_t	*device_uri;		/* Current DeviceURI match */

  debug_printf("DEBUG: %.3f Probing %s...\n", run_time(), device->addrname);

#ifdef __APPLE__

 /*

  * If the printer supports Bonjour/mDNS, don't report it from the SNMP backend.

  */

  if (!try_connect(&(device->address), device->addrname, 5353))

  {

    debug_printf("DEBUG: %s supports mDNS, not reporting!\n", device->addrname);

    return;

  }

#endif /* __APPLE__ */

 /*

  * Lookup the device in the match table...

  */

  for (device_uri = (device_uri_t *)cupsArrayFirst(DeviceURIs);

       device_uri;

       device_uri = (device_uri_t *)cupsArrayNext(DeviceURIs))

    if (device->make_and_model &&

        !regexec(&(device_uri->re), device->make_and_model, 0, NULL, 0))

    {

     /*

      * Found a match, add the URIs...

      */

      for (format = (char *)cupsArrayFirst(device_uri->uris);

           format;

	   format = (char *)cupsArrayNext(device_uri->uris))

      {

        for (uriptr = uri; *format && uriptr < (uri + sizeof(uri) - 1);)

	  if (*format == '%' && format[1] == 's')

	  {

	   /*

	    * Insert hostname/address...

	    */

	    strlcpy(uriptr, device->addrname, sizeof(uri) - (size_t)(uriptr - uri));

	    uriptr += strlen(uriptr);

	    format += 2;

	  }

	  else

	    *uriptr++ = *format++;

        *uriptr = '\0';

        update_cache(device, uri, NULL, NULL);

      }

      return;

    }

 /*

  * Then try the standard ports...

  */

  if (!try_connect(&(device->address), device->addrname, 9100))

  {

    debug_printf("DEBUG: %s supports AppSocket!\n", device->addrname);

    snprintf(uri, sizeof(uri), "socket://%s", device->addrname);

    update_cache(device, uri, NULL, NULL);

  }

  else if (!try_connect(&(device->address), device->addrname, 515))

  {

    debug_printf("DEBUG: %s supports LPD!\n", device->addrname);

    snprintf(uri, sizeof(uri), "lpd://%s/", device->addrname);

    update_cache(device, uri, NULL, NULL);

  }

}

/*

 * 'read_snmp_conf()' - Read the snmp.conf file.

 */

static void

read_snmp_conf(const char *address)	/* I - Single address to probe */

{

  cups_file_t	*fp;			/* File pointer */

  char		filename[1024],		/* Filename */

		line[1024],		/* Line from file */

		*value;			/* Value on line */

  int		linenum;		/* Line number */

  const char	*cups_serverroot;	/* CUPS_SERVERROOT env var */

  const char	*debug;			/* CUPS_DEBUG_LEVEL env var */

  const char	*runtime;		/* CUPS_MAX_RUN_TIME env var */

 /*

  * Initialize the global address and community lists...

  */

  Addresses   = cupsArrayNew(NULL, NULL);

  Communities = cupsArrayNew(NULL, NULL);

  if (address)

    add_array(Addresses, address);

  if ((debug = getenv("CUPS_DEBUG_LEVEL")) != NULL)

    DebugLevel = atoi(debug);

  if ((runtime = getenv("CUPS_MAX_RUN_TIME")) != NULL)

    MaxRunTime = atoi(runtime);

 /*

  * Find the snmp.conf file...

  */

  if ((cups_serverroot = getenv("CUPS_SERVERROOT")) == NULL)

    cups_serverroot = CUPS_SERVERROOT;

  snprintf(filename, sizeof(filename), "%s/snmp.conf", cups_serverroot);

  if ((fp = cupsFileOpen(filename, "r")) != NULL)

  {

   /*

    * Read the snmp.conf file...

    */

    linenum = 0;

    while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))

    {

      if (!value)

        fprintf(stderr, "ERROR: Missing value on line %d of %s!\n", linenum,

	        filename);

      else if (!_cups_strcasecmp(line, "Address"))

      {

        if (!address)

          add_array(Addresses, value);

      }

      else if (!_cups_strcasecmp(line, "Community"))

        add_array(Communities, value);

      else if (!_cups_strcasecmp(line, "DebugLevel"))

        DebugLevel = atoi(value);

      else if (!_cups_strcasecmp(line, "DeviceURI"))

      {

        if (*value != '\"')

	  fprintf(stderr,

	          "ERROR: Missing double quote for regular expression on "

		  "line %d of %s!\n", linenum, filename);

        else

	  add_device_uri(value);

      }

      else if (!_cups_strcasecmp(line, "HostNameLookups"))

        HostNameLookups = !_cups_strcasecmp(value, "on") ||

	                  !_cups_strcasecmp(value, "yes") ||

	                  !_cups_strcasecmp(value, "true") ||

	                  !_cups_strcasecmp(value, "double");

      else if (!_cups_strcasecmp(line, "MaxRunTime"))

        MaxRunTime = atoi(value);

      else

        fprintf(stderr, "ERROR: Unknown directive %s on line %d of %s!\n",

	        line, linenum, filename);

    }

    cupsFileClose(fp);

  }

 /*

  * Use defaults if parameters are undefined...

  */

  if (cupsArrayCount(Addresses) == 0)

  {

   /*

    * If we have no addresses, exit immediately...

    */

    fprintf(stderr,

            "DEBUG: No address specified and no Address line in %s...\n",

	    filename);

    exit(0);

  }

  if (cupsArrayCount(Communities) == 0)

  {

    fputs("INFO: Using default SNMP Community public\n", stderr);

    add_array(Communities, "public");

  }

}

/*

 * 'read_snmp_response()' - Read and parse a SNMP response...

 */