scheduler/cups-deviced.c

   1 /*
   2  * "$Id: cups-deviced.c 7011 2007-10-10 21:13:35Z mike $"
   3  *
   4  *   Device scanning mini-daemon for the Common UNIX Printing System (CUPS).
   5  *
   6  *   Copyright 2007 by Apple Inc.
   7  *   Copyright 1997-2006 by Easy Software Products.
   8  *
   9  *   These coded instructions, statements, and computer programs are the
  10  *   property of Apple Inc. and are protected by Federal copyright
  11  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  *   which should have been included with this file.  If this file is
  13  *   file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  * Contents:
  16  *
  17  *   main()            - Scan for devices and return an IPP response.
  18  *   add_dev()         - Add a new device to the list.
  19  *   compare_devs()    - Compare device names for sorting.
  20  *   run_backend()     - Run a backend to gather the available devices.
  21  *   sigalrm_handler() - Handle alarm signals for backends that get hung
  22  */
  23
  24 /*
  25  * Include necessary headers...
  26  */
  27
  28 #include "util.h"
  29 #include <cups/array.h>
  30 #include <cups/dir.h>
  31 #include <fcntl.h>
  32
  33
  34 /*
  35  * Device information structure...
  36  */
  37
  38 typedef struct
  39 {
  40   char  device_class[128],              /* Device class */
  41         device_make_and_model[128],     /* Make and model, if known */
  42         device_info[128],               /* Device info/description */
  43         device_uri[1024],               /* Device URI */
  44         device_id[1024];                /* 1284 Device ID */
  45 } dev_info_t;
  46
  47
  48 /*
  49  * Local globals...
  50  */
  51
  52 static int              alarm_tripped;  /* Non-zero if alarm was tripped */
  53 static cups_array_t     *devs;          /* Device info */
  54 static int              normal_user;    /* Normal user ID */
  55
  56
  57 /*
  58  * Local functions...
  59  */
  60
  61 static dev_info_t       *add_dev(const char *device_class,
  62                                  const char *device_make_and_model,
  63                                  const char *device_info,
  64                                  const char *device_uri,
  65                                  const char *device_id);
  66 static int              compare_devs(dev_info_t *p0, dev_info_t *p1);
  67 static FILE             *run_backend(const char *backend, int uid, int *pid);
  68 static void             sigalrm_handler(int sig);
  69
  70
  71 /*
  72  * 'main()' - Scan for devices and return an IPP response.
  73  *
  74  * Usage:
  75  *
  76  *    cups-deviced request_id limit options
  77  */
  78
  79 int                                     /* O - Exit code */
  80 main(int  argc,                         /* I - Number of command-line args */
  81      char *argv[])                      /* I - Command-line arguments */
  82 {
  83   const char    *server_bin;            /* CUPS_SERVERBIN environment variable */
  84   char          backends[1024];         /* Location of backends */
  85   int           request_id;             /* Request ID */
  86   int           count;                  /* Number of devices from backend */
  87   int           compat;                 /* Compatibility device? */
  88   FILE          *fp;                    /* Pipe to device backend */
  89   int           pid;                    /* Process ID of backend */
  90   cups_dir_t    *dir;                   /* Directory pointer */
  91   cups_dentry_t *dent;                  /* Directory entry */
  92   char          filename[1024],         /* Name of backend */
  93                 line[2048],             /* Line from backend */
  94                 dclass[64],             /* Device class */
  95                 uri[1024],              /* Device URI */
  96                 info[128],              /* Device info */
  97                 make_model[256],        /* Make and model */
  98                 device_id[1024];        /* 1284 device ID */
  99   int           num_options;            /* Number of options */
 100   cups_option_t *options;               /* Options */
 101   const char    *requested;             /* requested-attributes option */
 102   int           send_class,             /* Send device-class attribute? */
 103                 send_info,              /* Send device-info attribute? */
 104                 send_make_and_model,    /* Send device-make-and-model attribute? */
 105                 send_uri,               /* Send device-uri attribute? */
 106                 send_id;                /* Send device-id attribute? */
 107   dev_info_t    *dev;                   /* Current device */
 108 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
 109   struct sigaction action;              /* Actions for POSIX signals */
 110 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
 111
 112
 113   setbuf(stderr, NULL);
 114
 115  /*
 116   * Check the command-line...
 117   */
 118
 119   if (argc > 1)
 120     request_id = atoi(argv[1]);
 121   else
 122     request_id = 1;
 123
 124   if (argc != 5)
 125   {
 126     fputs("Usage: cups-deviced request-id limit user-id options\n", stderr);
 127
 128     return (1);
 129   }
 130
 131   if (request_id < 1)
 132   {
 133     fprintf(stderr, "cups-deviced: Bad request ID %d!\n", request_id);
 134
 135     return (1);
 136   }
 137
 138   normal_user = atoi(argv[3]);
 139   if (normal_user <= 0)
 140   {
 141     fprintf(stderr, "cups-deviced: Bad user %d!\n", normal_user);
 142
 143     return (1);
 144   }
 145
 146   num_options = cupsParseOptions(argv[4], 0, &options);
 147   requested   = cupsGetOption("requested-attributes", num_options, options);
 148
 149   if (!requested || strstr(requested, "all"))
 150   {
 151     send_class          = 1;
 152     send_info           = 1;
 153     send_make_and_model = 1;
 154     send_uri            = 1;
 155     send_id             = 1;
 156   }
 157   else
 158   {
 159     send_class          = strstr(requested, "device-class") != NULL;
 160     send_info           = strstr(requested, "device-info") != NULL;
 161     send_make_and_model = strstr(requested, "device-make-and-model") != NULL;
 162     send_uri            = strstr(requested, "device-uri") != NULL;
 163     send_id             = strstr(requested, "device-id") != NULL;
 164   }
 165
 166  /*
 167   * Try opening the backend directory...
 168   */
 169
 170   if ((server_bin = getenv("CUPS_SERVERBIN")) == NULL)
 171     server_bin = CUPS_SERVERBIN;
 172
 173   snprintf(backends, sizeof(backends), "%s/backend", server_bin);
 174
 175   if ((dir = cupsDirOpen(backends)) == NULL)
 176   {
 177     fprintf(stderr, "ERROR: [cups-deviced] Unable to open backend directory "
 178                     "\"%s\": %s", backends, strerror(errno));
 179
 180     return (1);
 181   }
 182
 183  /*
 184   * Setup the devices array...
 185   */
 186
 187   devs = cupsArrayNew((cups_array_func_t)compare_devs, NULL);
 188
 189  /*
 190   * Loop through all of the device backends...
 191   */
 192
 193   while ((dent = cupsDirRead(dir)) != NULL)
 194   {
 195    /*
 196     * Skip entries that are not executable files...
 197     */
 198
 199     if (!S_ISREG(dent->fileinfo.st_mode) ||
 200         (dent->fileinfo.st_mode & (S_IRUSR | S_IXUSR)) != (S_IRUSR | S_IXUSR))
 201       continue;
 202
 203    /*
 204     * Change effective users depending on the backend permissions...
 205     */
 206
 207     snprintf(filename, sizeof(filename), "%s/%s", backends, dent->filename);
 208
 209    /*
 210     * Backends without permissions for normal users run as root,
 211     * all others run as the unprivileged user...
 212     */
 213
 214     fp = run_backend(filename,
 215                      (dent->fileinfo.st_mode & (S_IRWXG | S_IRWXO))
 216                          ? normal_user : 0,
 217                      &pid);
 218
 219    /*
 220     * Collect the output from the backend...
 221     */
 222
 223     if (fp)
 224     {
 225      /*
 226       * Set an alarm for the first read from the backend; this avoids
 227       * problems when a backend is hung getting device information.
 228       */
 229
 230 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
 231       sigset(SIGALRM, sigalrm_handler);
 232 #elif defined(HAVE_SIGACTION)
 233       memset(&action, 0, sizeof(action));
 234
 235       sigemptyset(&action.sa_mask);
 236       sigaddset(&action.sa_mask, SIGALRM);
 237       action.sa_handler = sigalrm_handler;
 238       sigaction(SIGALRM, &action, NULL);
 239 #else
 240       signal(SIGALRM, sigalrm_handler);
 241 #endif /* HAVE_SIGSET */
 242
 243       alarm_tripped = 0;
 244       count         = 0;
 245       compat        = !strcmp(dent->filename, "smb");
 246
 247       alarm(30);
 248
 249       while (fgets(line, sizeof(line), fp) != NULL)
 250       {
 251        /*
 252         * Reset the alarm clock...
 253         */
 254
 255         alarm(30);
 256
 257        /*
 258         * Each line is of the form:
 259         *
 260         *   class URI "make model" "name" ["1284 device ID"]
 261         */
 262
 263         device_id[0] = '\0';
 264
 265         if (!strncasecmp(line, "Usage", 5))
 266           compat = 1;
 267         else if (sscanf(line,
 268                         "%63s%1023s%*[ \t]\"%255[^\"]\"%*[ \t]\"%127[^\"]\""
 269                         "%*[ \t]\"%1023[^\"]",
 270                         dclass, uri, make_model, info, device_id) < 4)
 271         {
 272          /*
 273           * Bad format; strip trailing newline and write an error message.
 274           */
 275
 276           if (line[strlen(line) - 1] == '\n')
 277             line[strlen(line) - 1] = '\0';
 278
 279           fprintf(stderr, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
 280                   dent->filename, line);
 281           compat = 1;
 282           break;
 283         }
 284         else
 285         {
 286          /*
 287           * Add the device to the array of available devices...
 288           */
 289
 290           dev = add_dev(dclass, make_model, info, uri, device_id);
 291           if (!dev)
 292           {
 293             cupsDirClose(dir);
 294             return (1);
 295           }
 296
 297           fprintf(stderr, "DEBUG: [cups-deviced] Added device \"%s\"...\n",
 298                   uri);
 299           count ++;
 300         }
 301       }
 302
 303      /*
 304       * Turn the alarm clock off and close the pipe to the command...
 305       */
 306
 307       alarm(0);
 308
 309       if (alarm_tripped)
 310         fprintf(stderr, "WARNING: [cups-deviced] Backend \"%s\" did not "
 311                         "respond within 30 seconds!\n", dent->filename);
 312
 313       fclose(fp);
 314       kill(pid, SIGTERM);
 315
 316      /*
 317       * Hack for backends that don't support the CUPS 1.1 calling convention:
 318       * add a network device with the method == backend name.
 319       */
 320
 321       if (count == 0 && compat)
 322       {
 323         snprintf(line, sizeof(line), "Unknown Network Device (%s)",
 324                  dent->filename);
 325
 326         dev = add_dev("network", line, "Unknown", dent->filename, "");
 327         if (!dev)
 328         {
 329           cupsDirClose(dir);
 330           return (1);
 331         }
 332
 333         fprintf(stderr, "DEBUG: [cups-deviced] Compatibility device "
 334                         "\"%s\"...\n", dent->filename);
 335       }
 336     }
 337     else
 338       fprintf(stderr, "WARNING: [cups-deviced] Unable to execute \"%s\" "
 339                       "backend: %s\n", dent->filename, strerror(errno));
 340   }
 341
 342   cupsDirClose(dir);
 343
 344  /*
 345   * Output the list of devices...
 346   */
 347
 348   puts("Content-Type: application/ipp\n");
 349
 350   cupsdSendIPPHeader(IPP_OK, request_id);
 351   cupsdSendIPPGroup(IPP_TAG_OPERATION);
 352   cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
 353   cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language", "en-US");
 354
 355   if ((count = atoi(argv[2])) <= 0)
 356     count = cupsArrayCount(devs);
 357
 358   if (count > cupsArrayCount(devs))
 359     count = cupsArrayCount(devs);
 360
 361   for (dev = (dev_info_t *)cupsArrayFirst(devs);
 362        count > 0;
 363        count --, dev = (dev_info_t *)cupsArrayNext(devs))
 364   {
 365    /*
 366     * Add strings to attributes...
 367     */
 368
 369     cupsdSendIPPGroup(IPP_TAG_PRINTER);
 370     if (send_class)
 371       cupsdSendIPPString(IPP_TAG_KEYWORD, "device-class", dev->device_class);
 372     if (send_info)
 373       cupsdSendIPPString(IPP_TAG_TEXT, "device-info", dev->device_info);
 374     if (send_make_and_model)
 375       cupsdSendIPPString(IPP_TAG_TEXT, "device-make-and-model",
 376                          dev->device_make_and_model);
 377     if (send_uri)
 378       cupsdSendIPPString(IPP_TAG_URI, "device-uri", dev->device_uri);
 379     if (send_id)
 380       cupsdSendIPPString(IPP_TAG_TEXT, "device-id", dev->device_id);
 381   }
 382
 383   cupsdSendIPPTrailer();
 384
 385  /*
 386   * Free the devices array and return...
 387   */
 388
 389   for (dev = (dev_info_t *)cupsArrayFirst(devs);
 390        dev;
 391        dev = (dev_info_t *)cupsArrayNext(devs))
 392     free(dev);
 393
 394   cupsArrayDelete(devs);
 395
 396   return (0);
 397 }
 398
 399
 400 /*
 401  * 'add_dev()' - Add a new device to the list.
 402  */
 403
 404 static dev_info_t *                     /* O - New device or NULL on error */
 405 add_dev(
 406     const char *device_class,           /* I - Device class */
 407     const char *device_make_and_model,  /* I - Device make and model */
 408     const char *device_info,            /* I - Device information */
 409     const char *device_uri,             /* I - Device URI */
 410     const char *device_id)              /* I - 1284 device ID */
 411 {
 412   dev_info_t    *dev,                   /* New device */
 413                 *temp;                  /* Found device */
 414
 415
 416  /*
 417   * Allocate memory for the device record...
 418   */
 419
 420   if ((dev = calloc(1, sizeof(dev_info_t))) == NULL)
 421   {
 422     fputs("ERROR: [cups-deviced] Ran out of memory allocating a device!\n",
 423           stderr);
 424     return (NULL);
 425   }
 426
 427  /*
 428   * Copy the strings over...
 429   */
 430
 431   strlcpy(dev->device_class, device_class, sizeof(dev->device_class));
 432   strlcpy(dev->device_make_and_model, device_make_and_model,
 433           sizeof(dev->device_make_and_model));
 434   strlcpy(dev->device_info, device_info, sizeof(dev->device_info));
 435   strlcpy(dev->device_uri, device_uri, sizeof(dev->device_uri));
 436   strlcpy(dev->device_id, device_id, sizeof(dev->device_id));
 437
 438  /*
 439   * Add the device to the array and return...
 440   */
 441
 442   if ((temp = cupsArrayFind(devs, dev)) != NULL)
 443   {
 444    /*
 445     * Avoid duplicates!
 446     */
 447
 448     free(dev);
 449     dev = temp;
 450   }
 451   else
 452     cupsArrayAdd(devs, dev);
 453
 454   return (dev);
 455 }
 456
 457
 458 /*
 459  * 'compare_devs()' - Compare device names for sorting.
 460  */
 461
 462 static int                              /* O - Result of comparison */
 463 compare_devs(dev_info_t *d0,            /* I - First device */
 464              dev_info_t *d1)            /* I - Second device */
 465 {
 466   int           diff;                   /* Difference between strings */
 467
 468
 469  /*
 470   * Sort devices by device-info, device-class, and device-uri...
 471   */
 472
 473   if ((diff = cupsdCompareNames(d0->device_info, d1->device_info)) != 0)
 474     return (diff);
 475   else if ((diff = strcasecmp(d0->device_class, d1->device_class)) != 0)
 476     return (diff);
 477   else
 478     return (strcasecmp(d0->device_uri, d1->device_uri));
 479 }
 480
 481
 482 /*
 483  * 'run_backend()' - Run a backend to gather the available devices.
 484  */
 485
 486 static FILE *                           /* O - stdout of backend */
 487 run_backend(const char *backend,        /* I - Backend to run */
 488             int        uid,             /* I - User ID to run as */
 489             int        *pid)            /* O - Process ID of backend */
 490 {
 491   int   fds[2];                         /* Pipe file descriptors */
 492
 493
 494   if (pipe(fds))
 495   {
 496     fprintf(stderr, "ERROR: Unable to create a pipe for \"%s\" - %s\n",
 497             backend, strerror(errno));
 498     return (NULL);
 499   }
 500
 501   if ((*pid = fork()) < 0)
 502   {
 503    /*
 504     * Error!
 505     */
 506
 507     fprintf(stderr, "ERROR: Unable to fork for \"%s\" - %s\n", backend,
 508             strerror(errno));
 509     close(fds[0]);
 510     close(fds[1]);
 511     return (NULL);
 512   }
 513   else if (!*pid)
 514   {
 515    /*
 516     * Child comes here...
 517     */
 518
 519     if (!getuid() && uid)
 520       setuid(uid);                      /* Run as restricted user */
 521
 522     close(0);                           /* </dev/null */
 523     open("/dev/null", O_RDONLY);
 524
 525     close(1);                           /* >pipe */
 526     dup(fds[1]);
 527
 528     close(fds[0]);                      /* Close copies of pipes */
 529     close(fds[1]);
 530
 531     execl(backend, backend, (char *)0); /* Run it! */
 532     fprintf(stderr, "ERROR: Unable to execute \"%s\" - %s\n", backend,
 533             strerror(errno));
 534     exit(1);
 535   }
 536
 537  /*
 538   * Parent comes here, make a FILE * from the input side of the pipe...
 539   */
 540
 541   close(fds[1]);
 542
 543   return (fdopen(fds[0], "r"));
 544 }
 545
 546
 547 /*
 548  * 'sigalrm_handler()' - Handle alarm signals for backends that get hung
 549  *                       trying to list the available devices...
 550  */
 551
 552 static void
 553 sigalrm_handler(int sig)                /* I - Signal number */
 554 {
 555   (void)sig; /* remove compiler warnings... */
 556
 557   alarm_tripped = 1;
 558 }
 559
 560
 561 /*
 562  * End of "$Id: cups-deviced.c 7011 2007-10-10 21:13:35Z mike $".
 563  */