]>
git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/cups-deviced.c
2 * "$Id: cups-deviced.c 6693 2007-07-19 21:02:36Z mike $"
4 * Device scanning mini-daemon for the Common UNIX Printing System (CUPS).
6 * Copyright 2007 by Apple Inc.
7 * Copyright 1997-2006 by Easy Software Products.
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/".
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
25 * Include necessary headers...
29 #include <cups/array.h>
35 * Device information structure...
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 */
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 */
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
);
72 * 'main()' - Scan for devices and return an IPP response.
76 * cups-deviced request_id limit options
79 int /* O - Exit code */
80 main(int argc
, /* I - Number of command-line args */
81 char *argv
[]) /* I - Command-line arguments */
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 */
113 setbuf(stderr
, NULL
);
116 * Check the command-line...
120 request_id
= atoi(argv
[1]);
126 fputs("Usage: cups-deviced request-id limit user-id options\n", stderr
);
133 fprintf(stderr
, "cups-deviced: Bad request ID %d!\n", request_id
);
138 normal_user
= atoi(argv
[3]);
139 if (normal_user
<= 0)
141 fprintf(stderr
, "cups-deviced: Bad user %d!\n", normal_user
);
146 num_options
= cupsParseOptions(argv
[4], 0, &options
);
147 requested
= cupsGetOption("requested-attributes", num_options
, options
);
149 if (!requested
|| strstr(requested
, "all"))
153 send_make_and_model
= 1;
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
;
167 * Try opening the backend directory...
170 if ((server_bin
= getenv("CUPS_SERVERBIN")) == NULL
)
171 server_bin
= CUPS_SERVERBIN
;
173 snprintf(backends
, sizeof(backends
), "%s/backend", server_bin
);
175 if ((dir
= cupsDirOpen(backends
)) == NULL
)
177 fprintf(stderr
, "ERROR: [cups-deviced] Unable to open backend directory "
178 "\"%s\": %s", backends
, strerror(errno
));
184 * Setup the devices array...
187 devs
= cupsArrayNew((cups_array_func_t
)compare_devs
, NULL
);
190 * Loop through all of the device backends...
193 while ((dent
= cupsDirRead(dir
)) != NULL
)
196 * Skip entries that are not executable files...
199 if (!S_ISREG(dent
->fileinfo
.st_mode
) ||
200 (dent
->fileinfo
.st_mode
& (S_IRUSR
| S_IXUSR
)) != (S_IRUSR
| S_IXUSR
))
204 * Change effective users depending on the backend permissions...
207 snprintf(filename
, sizeof(filename
), "%s/%s", backends
, dent
->filename
);
210 * Backends without permissions for normal users run as root,
211 * all others run as the unprivileged user...
214 fp
= run_backend(filename
,
215 (dent
->fileinfo
.st_mode
& (S_IRWXG
| S_IRWXO
))
220 * Collect the output from the backend...
226 * Set an alarm for the first read from the backend; this avoids
227 * problems when a backend is hung getting device information.
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
));
235 sigemptyset(&action
.sa_mask
);
236 sigaddset(&action
.sa_mask
, SIGALRM
);
237 action
.sa_handler
= sigalrm_handler
;
238 sigaction(SIGALRM
, &action
, NULL
);
240 signal(SIGALRM
, sigalrm_handler
);
241 #endif /* HAVE_SIGSET */
245 compat
= !strcmp(dent
->filename
, "smb");
249 while (fgets(line
, sizeof(line
), fp
) != NULL
)
252 * Reset the alarm clock...
258 * Each line is of the form:
260 * class URI "make model" "name" ["1284 device ID"]
265 if (!strncasecmp(line
, "Usage", 5))
267 else if (sscanf(line
,
268 "%63s%1023s%*[ \t]\"%255[^\"]\"%*[ \t]\"%127[^\"]\""
269 "%*[ \t]\"%1023[^\"]",
270 dclass
, uri
, make_model
, info
, device_id
) < 4)
273 * Bad format; strip trailing newline and write an error message.
276 if (line
[strlen(line
) - 1] == '\n')
277 line
[strlen(line
) - 1] = '\0';
279 fprintf(stderr
, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
280 dent
->filename
, line
);
287 * Add the device to the array of available devices...
290 dev
= add_dev(dclass
, make_model
, info
, uri
, device_id
);
297 fprintf(stderr
, "DEBUG: [cups-deviced] Added device \"%s\"...\n",
304 * Turn the alarm clock off and close the pipe to the command...
310 fprintf(stderr
, "WARNING: [cups-deviced] Backend \"%s\" did not "
311 "respond within 30 seconds!\n", dent
->filename
);
317 * Hack for backends that don't support the CUPS 1.1 calling convention:
318 * add a network device with the method == backend name.
321 if (count
== 0 && compat
)
323 snprintf(line
, sizeof(line
), "Unknown Network Device (%s)",
326 dev
= add_dev("network", line
, "Unknown", dent
->filename
, "");
333 fprintf(stderr
, "DEBUG: [cups-deviced] Compatibility device "
334 "\"%s\"...\n", dent
->filename
);
338 fprintf(stderr
, "WARNING: [cups-deviced] Unable to execute \"%s\" "
339 "backend: %s\n", dent
->filename
, strerror(errno
));
345 * Output the list of devices...
348 puts("Content-Type: application/ipp\n");
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");
355 if ((count
= atoi(argv
[2])) <= 0)
356 count
= cupsArrayCount(devs
);
358 if (count
> cupsArrayCount(devs
))
359 count
= cupsArrayCount(devs
);
361 for (dev
= (dev_info_t
*)cupsArrayFirst(devs
);
363 count
--, dev
= (dev_info_t
*)cupsArrayNext(devs
))
366 * Add strings to attributes...
369 cupsdSendIPPGroup(IPP_TAG_PRINTER
);
371 cupsdSendIPPString(IPP_TAG_KEYWORD
, "device-class", dev
->device_class
);
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
);
378 cupsdSendIPPString(IPP_TAG_URI
, "device-uri", dev
->device_uri
);
380 cupsdSendIPPString(IPP_TAG_TEXT
, "device-id", dev
->device_id
);
383 cupsdSendIPPTrailer();
386 * Free the devices array and return...
389 for (dev
= (dev_info_t
*)cupsArrayFirst(devs
);
391 dev
= (dev_info_t
*)cupsArrayNext(devs
))
394 cupsArrayDelete(devs
);
401 * 'add_dev()' - Add a new device to the list.
404 static dev_info_t
* /* O - New device or NULL on error */
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 */
412 dev_info_t
*dev
; /* New device */
416 * Allocate memory for the device record...
419 if ((dev
= calloc(1, sizeof(dev_info_t
))) == NULL
)
421 fputs("ERROR: [cups-deviced] Ran out of memory allocating a device!\n",
427 * Copy the strings over...
430 strlcpy(dev
->device_class
, device_class
, sizeof(dev
->device_class
));
431 strlcpy(dev
->device_make_and_model
, device_make_and_model
,
432 sizeof(dev
->device_make_and_model
));
433 strlcpy(dev
->device_info
, device_info
, sizeof(dev
->device_info
));
434 strlcpy(dev
->device_uri
, device_uri
, sizeof(dev
->device_uri
));
435 strlcpy(dev
->device_id
, device_id
, sizeof(dev
->device_id
));
438 * Add the device to the array and return...
441 cupsArrayAdd(devs
, dev
);
448 * 'compare_devs()' - Compare device names for sorting.
451 static int /* O - Result of comparison */
452 compare_devs(dev_info_t
*d0
, /* I - First device */
453 dev_info_t
*d1
) /* I - Second device */
455 int diff
; /* Difference between strings */
459 * Sort devices by device-info, device-class, and device-uri...
462 if ((diff
= cupsdCompareNames(d0
->device_info
, d1
->device_info
)) != 0)
464 else if ((diff
= strcasecmp(d0
->device_class
, d1
->device_class
)) != 0)
467 return (strcasecmp(d0
->device_uri
, d1
->device_uri
));
472 * 'run_backend()' - Run a backend to gather the available devices.
475 static FILE * /* O - stdout of backend */
476 run_backend(const char *backend
, /* I - Backend to run */
477 int uid
, /* I - User ID to run as */
478 int *pid
) /* O - Process ID of backend */
480 int fds
[2]; /* Pipe file descriptors */
485 fprintf(stderr
, "ERROR: Unable to create a pipe for \"%s\" - %s\n",
486 backend
, strerror(errno
));
490 if ((*pid
= fork()) < 0)
496 fprintf(stderr
, "ERROR: Unable to fork for \"%s\" - %s\n", backend
,
505 * Child comes here...
508 if (!getuid() && uid
)
509 setuid(uid
); /* Run as restricted user */
511 close(0); /* </dev/null */
512 open("/dev/null", O_RDONLY
);
514 close(1); /* >pipe */
517 close(fds
[0]); /* Close copies of pipes */
520 execl(backend
, backend
, (char *)0); /* Run it! */
521 fprintf(stderr
, "ERROR: Unable to execute \"%s\" - %s\n", backend
,
527 * Parent comes here, make a FILE * from the input side of the pipe...
532 return (fdopen(fds
[0], "r"));
537 * 'sigalrm_handler()' - Handle alarm signals for backends that get hung
538 * trying to list the available devices...
542 sigalrm_handler(int sig
) /* I - Signal number */
544 (void)sig
; /* remove compiler warnings... */
551 * End of "$Id: cups-deviced.c 6693 2007-07-19 21:02:36Z mike $".