cups/getdevices.c

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