cups/getdevices.c

   1 /*
   2  * "$Id$"
   3  *
   4  *   cupsGetDevices implementation for CUPS.
   5  *
   6  *   Copyright 2008-2010 by Apple Inc.
   7  *
   8  *   These coded instructions, statements, and computer programs are the
   9  *   property of Apple Inc. and are protected by Federal copyright
  10  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  11  *   which should have been included with this file.  If this file is
  12  *   file is missing or damaged, see the license at "http://www.cups.org/".
  13  *
  14  *   This file is subject to the Apple OS-Developed Software exception.
  15  *
  16  * Contents:
  17  *
  18  *   cupsGetDevices() - Get available printer devices.
  19  */
  20
  21 /*
  22  * Include necessary headers...
  23  */
  24
  25 #include "cups-private.h"
  26
  27
  28 /*
  29  * 'cupsGetDevices()' - Get available printer devices.
  30  *
  31  * This function sends a CUPS-Get-Devices request and streams the discovered
  32  * devices to the specified callback function. The "timeout" parameter controls
  33  * how long the request lasts, while the "include_schemes" and "exclude_schemes"
  34  * parameters provide comma-delimited lists of backends to include or omit from
  35  * the request respectively.
  36  *
  37  * @since CUPS 1.4/Mac OS X 10.6@
  38  */
  39
  40 ipp_status_t                            /* O - Request status - @code IPP_OK@ on success. */
  41 cupsGetDevices(
  42     http_t           *http,             /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
  43     int              timeout,           /* I - Timeout in seconds or @code CUPS_TIMEOUT_DEFAULT@ */
  44     const char       *include_schemes,  /* I - Comma-separated URI schemes to include or @code CUPS_INCLUDE_ALL@ */
  45     const char       *exclude_schemes,  /* I - Comma-separated URI schemes to exclude or @code CUPS_EXCLUDE_NONE@ */
  46     cups_device_cb_t callback,          /* I - Callback function */
  47     void             *user_data)        /* I - User data pointer */
  48 {
  49   ipp_t         *request,               /* CUPS-Get-Devices request */
  50                 *response;              /* CUPS-Get-Devices response */
  51   ipp_attribute_t *attr;                /* Current attribute */
  52   const char    *device_class,          /* device-class value */
  53                 *device_id,             /* device-id value */
  54                 *device_info,           /* device-info value */
  55                 *device_location,       /* device-location value */
  56                 *device_make_and_model, /* device-make-and-model value */
  57                 *device_uri;            /* device-uri value */
  58   int           blocking;               /* Current blocking-IO mode */
  59   cups_option_t option;                 /* in/exclude-schemes option */
  60   http_status_t status;                 /* HTTP status of request */
  61   ipp_state_t   state;                  /* IPP response state */
  62
  63
  64  /*
  65   * Range check input...
  66   */
  67
  68   DEBUG_printf(("cupsGetDevices(http=%p, timeout=%d, include_schemes=\"%s\", "
  69                 "exclude_schemes=\"%s\", callback=%p, user_data=%p)", http,
  70                 timeout, include_schemes, exclude_schemes, callback,
  71                 user_data));
  72
  73   if (!callback)
  74     return (IPP_INTERNAL_ERROR);
  75
  76   if (!http)
  77     http = _cupsConnect();
  78
  79   if (!http)
  80     return (IPP_SERVICE_UNAVAILABLE);
  81
  82  /*
  83   * Create a CUPS-Get-Devices request...
  84   */
  85
  86   request = ippNewRequest(CUPS_GET_DEVICES);
  87
  88   if (timeout > 0)
  89     ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "timeout",
  90                   timeout);
  91
  92   if (include_schemes)
  93   {
  94     option.name  = "include-schemes";
  95     option.value = (char *)include_schemes;
  96
  97     cupsEncodeOptions2(request, 1, &option, IPP_TAG_OPERATION);
  98   }
  99
 100   if (exclude_schemes)
 101   {
 102     option.name  = "exclude-schemes";
 103     option.value = (char *)exclude_schemes;
 104
 105     cupsEncodeOptions2(request, 1, &option, IPP_TAG_OPERATION);
 106   }
 107
 108  /*
 109   * Send the request and do any necessary authentication...
 110   */
 111
 112   do
 113   {
 114     DEBUG_puts("2cupsGetDevices: Sending request...");
 115     status = cupsSendRequest(http, request, "/", ippLength(request));
 116
 117     DEBUG_puts("2cupsGetDevices: Waiting for response status...");
 118     while (status == HTTP_CONTINUE)
 119       status = httpUpdate(http);
 120
 121     if (status != HTTP_OK)
 122     {
 123       httpFlush(http);
 124
 125       if (status == HTTP_UNAUTHORIZED)
 126       {
 127        /*
 128         * See if we can do authentication...
 129         */
 130
 131         DEBUG_puts("2cupsGetDevices: Need authorization...");
 132
 133         if (!cupsDoAuthentication(http, "POST", "/"))
 134           httpReconnect(http);
 135         else
 136         {
 137           status = HTTP_AUTHORIZATION_CANCELED;
 138           break;
 139         }
 140       }
 141
 142 #ifdef HAVE_SSL
 143       else if (status == HTTP_UPGRADE_REQUIRED)
 144       {
 145        /*
 146         * Force a reconnect with encryption...
 147         */
 148
 149         DEBUG_puts("2cupsGetDevices: Need encryption...");
 150
 151         if (!httpReconnect(http))
 152           httpEncryption(http, HTTP_ENCRYPT_REQUIRED);
 153       }
 154 #endif /* HAVE_SSL */
 155     }
 156   }
 157   while (status == HTTP_UNAUTHORIZED || status == HTTP_UPGRADE_REQUIRED);
 158
 159   DEBUG_printf(("2cupsGetDevices: status=%d", status));
 160
 161   ippDelete(request);
 162
 163   if (status != HTTP_OK)
 164   {
 165     _cupsSetHTTPError(status);
 166     return (cupsLastError());
 167   }
 168
 169  /*
 170   * Read the response in non-blocking mode...
 171   */
 172
 173   blocking = httpGetBlocking(http);
 174   httpBlocking(http, 0);
 175
 176   response              = ippNew();
 177   device_class          = NULL;
 178   device_id             = NULL;
 179   device_info           = NULL;
 180   device_location       = "";
 181   device_make_and_model = NULL;
 182   device_uri            = NULL;
 183   attr                  = NULL;
 184
 185   DEBUG_puts("2cupsGetDevices: Reading response...");
 186
 187   do
 188   {
 189     if ((state = ippRead(http, response)) == IPP_ERROR)
 190       break;
 191
 192     DEBUG_printf(("2cupsGetDevices: state=%d, response->last=%p", state,
 193                   response->last));
 194
 195     if (!response->attrs)
 196       continue;
 197
 198     while (attr != response->last)
 199     {
 200       if (!attr)
 201         attr = response->attrs;
 202       else
 203         attr = attr->next;
 204
 205       DEBUG_printf(("2cupsGetDevices: attr->name=\"%s\", attr->value_tag=%d",
 206                     attr->name, attr->value_tag));
 207
 208       if (!attr->name)
 209       {
 210         if (device_class && device_id && device_info && device_make_and_model &&
 211             device_uri)
 212           (*callback)(device_class, device_id, device_info,
 213                       device_make_and_model, device_uri, device_location,
 214                       user_data);
 215
 216         device_class          = NULL;
 217         device_id             = NULL;
 218         device_info           = NULL;
 219         device_location       = "";
 220         device_make_and_model = NULL;
 221         device_uri            = NULL;
 222       }
 223       else if (!strcmp(attr->name, "device-class") &&
 224                attr->value_tag == IPP_TAG_KEYWORD)
 225         device_class = attr->values[0].string.text;
 226       else if (!strcmp(attr->name, "device-id") &&
 227                attr->value_tag == IPP_TAG_TEXT)
 228         device_id = attr->values[0].string.text;
 229       else if (!strcmp(attr->name, "device-info") &&
 230                attr->value_tag == IPP_TAG_TEXT)
 231         device_info = attr->values[0].string.text;
 232       else if (!strcmp(attr->name, "device-location") &&
 233                attr->value_tag == IPP_TAG_TEXT)
 234         device_location = attr->values[0].string.text;
 235       else if (!strcmp(attr->name, "device-make-and-model") &&
 236                attr->value_tag == IPP_TAG_TEXT)
 237         device_make_and_model = attr->values[0].string.text;
 238       else if (!strcmp(attr->name, "device-uri") &&
 239                attr->value_tag == IPP_TAG_URI)
 240         device_uri = attr->values[0].string.text;
 241     }
 242   }
 243   while (state != IPP_DATA);
 244
 245   DEBUG_printf(("2cupsGetDevices: state=%d, response->last=%p", state,
 246                 response->last));
 247
 248   if (device_class && device_id && device_info && device_make_and_model &&
 249       device_uri)
 250     (*callback)(device_class, device_id, device_info,
 251                 device_make_and_model, device_uri, device_location, user_data);
 252
 253  /*
 254   * Set the IPP status and return...
 255   */
 256
 257   httpBlocking(http, blocking);
 258   httpFlush(http);
 259
 260   if (status == HTTP_ERROR)
 261     _cupsSetError(IPP_ERROR, NULL, 0);
 262   else
 263   {
 264     attr = ippFindAttribute(response, "status-message", IPP_TAG_TEXT);
 265
 266     DEBUG_printf(("cupsGetDevices: status-code=%s, status-message=\"%s\"",
 267                   ippErrorString(response->request.status.status_code),
 268                   attr ? attr->values[0].string.text : ""));
 269
 270     _cupsSetError(response->request.status.status_code,
 271                   attr ? attr->values[0].string.text :
 272                       ippErrorString(response->request.status.status_code), 0);
 273   }
 274
 275   ippDelete(response);
 276
 277   return (cupsLastError());
 278 }
 279
 280
 281 /*
 282  * End of "$Id$".
 283  */