]>
git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/cups-deviced.c
2 * "$Id: cups-deviced.c 6649 2007-07-11 21:46:42Z 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 * sigalrm_handler() - Handle alarm signals for backends that get hung
24 * Include necessary headers...
28 #include <cups/array.h>
32 # define seteuid(uid) setresuid(-1, (uid), -1)
37 * Device information structure...
42 char device_class
[128], /* Device class */
43 device_make_and_model
[128], /* Make and model, if known */
44 device_info
[128], /* Device info/description */
45 device_uri
[1024], /* Device URI */
46 device_id
[1024]; /* 1284 Device ID */
54 static int alarm_tripped
; /* Non-zero if alarm was tripped */
55 static cups_array_t
*devs
; /* Device info */
56 static int normal_user
; /* Normal user ID */
63 static dev_info_t
*add_dev(const char *device_class
,
64 const char *device_make_and_model
,
65 const char *device_info
,
66 const char *device_uri
,
67 const char *device_id
);
68 static int compare_devs(dev_info_t
*p0
, dev_info_t
*p1
);
69 static void sigalrm_handler(int sig
);
73 * 'main()' - Scan for devices and return an IPP response.
77 * cups-deviced request_id limit options
80 int /* O - Exit code */
81 main(int argc
, /* I - Number of command-line args */
82 char *argv
[]) /* I - Command-line arguments */
84 const char *server_bin
; /* CUPS_SERVERBIN environment variable */
85 char backends
[1024]; /* Location of backends */
86 int request_id
; /* Request ID */
87 int count
; /* Number of devices from backend */
88 int compat
; /* Compatibility device? */
89 FILE *fp
; /* Pipe to device 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...
210 * Backends without permissions for normal users run as root,
211 * all others run as the unprivileged user...
214 if (!(dent
->fileinfo
.st_mode
& (S_IRWXG
| S_IRWXO
)))
217 seteuid(normal_user
);
221 * Run the backend with no arguments and collect the output...
224 snprintf(filename
, sizeof(filename
), "%s/%s", backends
, dent
->filename
);
225 if ((fp
= popen(filename
, "r")) != NULL
)
228 * Set an alarm for the first read from the backend; this avoids
229 * problems when a backend is hung getting device information.
232 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
233 sigset(SIGALRM
, sigalrm_handler
);
234 #elif defined(HAVE_SIGACTION)
235 memset(&action
, 0, sizeof(action
));
237 sigemptyset(&action
.sa_mask
);
238 sigaddset(&action
.sa_mask
, SIGALRM
);
239 action
.sa_handler
= sigalrm_handler
;
240 sigaction(SIGALRM
, &action
, NULL
);
242 signal(SIGALRM
, sigalrm_handler
);
243 #endif /* HAVE_SIGSET */
247 compat
= !strcmp(dent
->filename
, "smb");
251 while (fgets(line
, sizeof(line
), fp
) != NULL
)
254 * Reset the alarm clock...
260 * Each line is of the form:
262 * class URI "make model" "name" ["1284 device ID"]
267 if (!strncasecmp(line
, "Usage", 5))
269 else if (sscanf(line
,
270 "%63s%1023s%*[ \t]\"%255[^\"]\"%*[ \t]\"%127[^\"]\""
271 "%*[ \t]\"%1023[^\"]",
272 dclass
, uri
, make_model
, info
, device_id
) < 4)
275 * Bad format; strip trailing newline and write an error message.
278 if (line
[strlen(line
) - 1] == '\n')
279 line
[strlen(line
) - 1] = '\0';
281 fprintf(stderr
, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
282 dent
->filename
, line
);
289 * Add the device to the array of available devices...
292 dev
= add_dev(dclass
, make_model
, info
, uri
, device_id
);
299 fprintf(stderr
, "DEBUG: [cups-deviced] Added device \"%s\"...\n",
306 * Turn the alarm clock off and close the pipe to the command...
312 fprintf(stderr
, "WARNING: [cups-deviced] Backend \"%s\" did not "
313 "respond within 30 seconds!\n", dent
->filename
);
318 * Hack for backends that don't support the CUPS 1.1 calling convention:
319 * add a network device with the method == backend name.
322 if (count
== 0 && compat
)
324 snprintf(line
, sizeof(line
), "Unknown Network Device (%s)",
327 dev
= add_dev("network", line
, "Unknown", dent
->filename
, "");
334 fprintf(stderr
, "DEBUG: [cups-deviced] Compatibility device "
335 "\"%s\"...\n", dent
->filename
);
339 fprintf(stderr
, "WARNING: [cups-deviced] Unable to execute \"%s\" "
340 "backend: %s\n", dent
->filename
, strerror(errno
));
346 * Switch back to root as needed...
349 if (!getuid() && geteuid())
353 * Output the list of devices...
356 puts("Content-Type: application/ipp\n");
358 cupsdSendIPPHeader(IPP_OK
, request_id
);
359 cupsdSendIPPGroup(IPP_TAG_OPERATION
);
360 cupsdSendIPPString(IPP_TAG_CHARSET
, "attributes-charset", "utf-8");
361 cupsdSendIPPString(IPP_TAG_LANGUAGE
, "attributes-natural-language", "en-US");
363 if ((count
= atoi(argv
[2])) <= 0)
364 count
= cupsArrayCount(devs
);
366 if (count
> cupsArrayCount(devs
))
367 count
= cupsArrayCount(devs
);
369 for (dev
= (dev_info_t
*)cupsArrayFirst(devs
);
371 count
--, dev
= (dev_info_t
*)cupsArrayNext(devs
))
374 * Add strings to attributes...
377 cupsdSendIPPGroup(IPP_TAG_PRINTER
);
379 cupsdSendIPPString(IPP_TAG_KEYWORD
, "device-class", dev
->device_class
);
381 cupsdSendIPPString(IPP_TAG_TEXT
, "device-info", dev
->device_info
);
382 if (send_make_and_model
)
383 cupsdSendIPPString(IPP_TAG_TEXT
, "device-make-and-model",
384 dev
->device_make_and_model
);
386 cupsdSendIPPString(IPP_TAG_URI
, "device-uri", dev
->device_uri
);
388 cupsdSendIPPString(IPP_TAG_TEXT
, "device-id", dev
->device_id
);
391 cupsdSendIPPTrailer();
394 * Free the devices array and return...
397 for (dev
= (dev_info_t
*)cupsArrayFirst(devs
);
399 dev
= (dev_info_t
*)cupsArrayNext(devs
))
402 cupsArrayDelete(devs
);
409 * 'add_dev()' - Add a new device to the list.
412 static dev_info_t
* /* O - New device or NULL on error */
414 const char *device_class
, /* I - Device class */
415 const char *device_make_and_model
, /* I - Device make and model */
416 const char *device_info
, /* I - Device information */
417 const char *device_uri
, /* I - Device URI */
418 const char *device_id
) /* I - 1284 device ID */
420 dev_info_t
*dev
; /* New device */
424 * Allocate memory for the device record...
427 if ((dev
= calloc(1, sizeof(dev_info_t
))) == NULL
)
429 fputs("ERROR: [cups-deviced] Ran out of memory allocating a device!\n",
435 * Copy the strings over...
438 strlcpy(dev
->device_class
, device_class
, sizeof(dev
->device_class
));
439 strlcpy(dev
->device_make_and_model
, device_make_and_model
,
440 sizeof(dev
->device_make_and_model
));
441 strlcpy(dev
->device_info
, device_info
, sizeof(dev
->device_info
));
442 strlcpy(dev
->device_uri
, device_uri
, sizeof(dev
->device_uri
));
443 strlcpy(dev
->device_id
, device_id
, sizeof(dev
->device_id
));
446 * Add the device to the array and return...
449 cupsArrayAdd(devs
, dev
);
456 * 'compare_devs()' - Compare device names for sorting.
459 static int /* O - Result of comparison */
460 compare_devs(dev_info_t
*d0
, /* I - First device */
461 dev_info_t
*d1
) /* I - Second device */
463 int diff
; /* Difference between strings */
467 * Sort devices by device-info, device-class, and device-uri...
470 if ((diff
= cupsdCompareNames(d0
->device_info
, d1
->device_info
)) != 0)
472 else if ((diff
= strcasecmp(d0
->device_class
, d1
->device_class
)) != 0)
475 return (strcasecmp(d0
->device_uri
, d1
->device_uri
));
480 * 'sigalrm_handler()' - Handle alarm signals for backends that get hung
481 * trying to list the available devices...
485 sigalrm_handler(int sig
) /* I - Signal number */
487 (void)sig
; /* remove compiler warnings... */
494 * End of "$Id: cups-deviced.c 6649 2007-07-11 21:46:42Z mike $".