]>
git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/cups-deviced.c
2 * "$Id: cups-deviced.c 5099 2006-02-13 02:46:10Z mike $"
4 * Device scanning mini-daemon for the Common UNIX Printing System (CUPS).
6 * Copyright 1997-2006 by Easy Software Products.
8 * These coded instructions, statements, and computer programs are the
9 * property of Easy Software Products and are protected by Federal
10 * copyright law. Distribution and use rights are outlined in the file
11 * "LICENSE.txt" which should have been included with this file. If this
12 * file is missing or damaged please contact Easy Software Products
15 * Attn: CUPS Licensing Information
16 * Easy Software Products
17 * 44141 Airport View Drive, Suite 204
18 * Hollywood, Maryland 20636 USA
20 * Voice: (301) 373-9600
21 * EMail: cups-info@cups.org
22 * WWW: http://www.cups.org
26 * main() - Scan for devices and return an IPP response.
27 * add_dev() - Add a new device to the list.
28 * compare_devs() - Compare device names for sorting.
29 * sigalrm_handler() - Handle alarm signals for backends that get hung
33 * Include necessary headers...
37 #include <cups/array.h>
42 * Device information structure...
47 char device_class
[128], /* Device class */
48 device_make_and_model
[128], /* Make and model, if known */
49 device_info
[128], /* Device info/description */
50 device_uri
[1024], /* Device URI */
51 device_id
[1024]; /* 1284 Device ID */
59 static int alarm_tripped
; /* Non-zero if alarm was tripped */
60 static cups_array_t
*devs
; /* Device info */
61 static int normal_user
; /* Normal user ID */
68 static dev_info_t
*add_dev(const char *device_class
,
69 const char *device_make_and_model
,
70 const char *device_info
,
71 const char *device_uri
,
72 const char *device_id
);
73 static int compare_devs(dev_info_t
*p0
, dev_info_t
*p1
);
74 static void sigalrm_handler(int sig
);
78 * 'main()' - Scan for devices and return an IPP response.
82 * cups-deviced request_id limit options
85 int /* O - Exit code */
86 main(int argc
, /* I - Number of command-line args */
87 char *argv
[]) /* I - Command-line arguments */
89 const char *server_bin
; /* CUPS_SERVERBIN environment variable */
90 char backends
[1024]; /* Location of backends */
91 int request_id
; /* Request ID */
92 int count
; /* Number of devices from backend */
93 int compat
; /* Compatibility device? */
94 FILE *fp
; /* Pipe to device backend */
95 cups_dir_t
*dir
; /* Directory pointer */
96 cups_dentry_t
*dent
; /* Directory entry */
97 char filename
[1024], /* Name of backend */
98 line
[2048], /* Line from backend */
99 dclass
[64], /* Device class */
100 uri
[1024], /* Device URI */
101 info
[128], /* Device info */
102 make_model
[256], /* Make and model */
103 device_id
[1024]; /* 1284 device ID */
104 int num_options
; /* Number of options */
105 cups_option_t
*options
; /* Options */
106 const char *requested
; /* requested-attributes option */
107 int send_class
, /* Send device-class attribute? */
108 send_info
, /* Send device-info attribute? */
109 send_make_and_model
, /* Send device-make-and-model attribute? */
110 send_uri
, /* Send device-uri attribute? */
111 send_id
; /* Send device-id attribute? */
112 dev_info_t
*dev
; /* Current device */
113 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
114 struct sigaction action
; /* Actions for POSIX signals */
115 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
118 setbuf(stderr
, NULL
);
121 * Check the command-line...
125 request_id
= atoi(argv
[1]);
131 fputs("Usage: cups-deviced request-id limit user-id options\n", stderr
);
138 fprintf(stderr
, "cups-deviced: Bad request ID %d!\n", request_id
);
143 normal_user
= atoi(argv
[3]);
144 if (normal_user
<= 0)
146 fprintf(stderr
, "cups-deviced: Bad user %d!\n", normal_user
);
151 num_options
= cupsParseOptions(argv
[4], 0, &options
);
152 requested
= cupsGetOption("requested-attributes", num_options
, options
);
154 if (!requested
|| strstr(requested
, "all"))
158 send_make_and_model
= 1;
164 send_class
= strstr(requested
, "device-class") != NULL
;
165 send_info
= strstr(requested
, "device-info") != NULL
;
166 send_make_and_model
= strstr(requested
, "device-make-and-model") != NULL
;
167 send_uri
= strstr(requested
, "device-uri") != NULL
;
168 send_id
= strstr(requested
, "device-id") != NULL
;
172 * Try opening the backend directory...
175 if ((server_bin
= getenv("CUPS_SERVERBIN")) == NULL
)
176 server_bin
= CUPS_SERVERBIN
;
178 snprintf(backends
, sizeof(backends
), "%s/backend", server_bin
);
180 if ((dir
= cupsDirOpen(backends
)) == NULL
)
182 fprintf(stderr
, "ERROR: [cups-deviced] Unable to open backend directory "
183 "\"%s\": %s", backends
, strerror(errno
));
189 * Setup the devices array...
192 devs
= cupsArrayNew((cups_array_func_t
)compare_devs
, NULL
);
195 * Loop through all of the device backends...
198 while ((dent
= cupsDirRead(dir
)) != NULL
)
201 * Skip entries that are not executable files...
204 if (!S_ISREG(dent
->fileinfo
.st_mode
) ||
205 (dent
->fileinfo
.st_mode
& (S_IRUSR
| S_IXUSR
)) != (S_IRUSR
| S_IXUSR
))
209 * Change effective users depending on the backend permissions...
215 * Backends without permissions for normal users run as root,
216 * all others run as the unprivileged user...
219 if (!(dent
->fileinfo
.st_mode
& (S_IRWXG
| S_IRWXO
)))
222 seteuid(normal_user
);
226 * Run the backend with no arguments and collect the output...
229 snprintf(filename
, sizeof(filename
), "%s/%s", backends
, dent
->filename
);
230 if ((fp
= popen(filename
, "r")) != NULL
)
233 * Set an alarm for the first read from the backend; this avoids
234 * problems when a backend is hung getting device information.
237 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
238 sigset(SIGALRM
, sigalrm_handler
);
239 #elif defined(HAVE_SIGACTION)
240 memset(&action
, 0, sizeof(action
));
242 sigemptyset(&action
.sa_mask
);
243 sigaddset(&action
.sa_mask
, SIGALRM
);
244 action
.sa_handler
= sigalrm_handler
;
245 sigaction(SIGALRM
, &action
, NULL
);
247 signal(SIGALRM
, sigalrm_handler
);
248 #endif /* HAVE_SIGSET */
252 compat
= !strcmp(dent
->filename
, "smb");
256 while (fgets(line
, sizeof(line
), fp
) != NULL
)
259 * Reset the alarm clock...
265 * Each line is of the form:
267 * class URI "make model" "name" ["1284 device ID"]
272 if (!strncasecmp(line
, "Usage", 5))
274 else if (sscanf(line
,
275 "%63s%1023s%*[ \t]\"%255[^\"]\"%*[ \t]\"%127[^\"]"
276 "%*[ \t]\"%1023[^\"]",
277 dclass
, uri
, make_model
, info
, device_id
) < 4)
280 * Bad format; strip trailing newline and write an error message.
283 if (line
[strlen(line
) - 1] == '\n')
284 line
[strlen(line
) - 1] = '\0';
286 fprintf(stderr
, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
287 dent
->filename
, line
);
294 * Add the device to the array of available devices...
297 dev
= add_dev(dclass
, make_model
, info
, uri
, device_id
);
304 fprintf(stderr
, "DEBUG: [cups-deviced] Added device \"%s\"...\n",
311 * Turn the alarm clock off and close the pipe to the command...
317 fprintf(stderr
, "WARNING: [cups-deviced] Backend \"%s\" did not "
318 "respond within 30 seconds!\n", dent
->filename
);
323 * Hack for backends that don't support the CUPS 1.1 calling convention:
324 * add a network device with the method == backend name.
327 if (count
== 0 && compat
)
329 snprintf(line
, sizeof(line
), "Unknown Network Device (%s)",
332 dev
= add_dev("network", line
, "Unknown", dent
->filename
, "");
339 fprintf(stderr
, "DEBUG: [cups-deviced] Compatibility device "
340 "\"%s\"...\n", dent
->filename
);
344 fprintf(stderr
, "WARNING: [cups-deviced] Unable to execute \"%s\" "
345 "backend: %s\n", dent
->filename
, strerror(errno
));
351 * Switch back to root as needed...
354 if (!getuid() && geteuid())
358 * Output the list of devices...
361 puts("Content-Type: application/ipp\n");
363 cupsdSendIPPHeader(IPP_OK
, request_id
);
364 cupsdSendIPPGroup(IPP_TAG_OPERATION
);
365 cupsdSendIPPString(IPP_TAG_CHARSET
, "attributes-charset", "utf-8");
366 cupsdSendIPPString(IPP_TAG_LANGUAGE
, "attributes-natural-language", "en-US");
368 if ((count
= atoi(argv
[2])) <= 0)
369 count
= cupsArrayCount(devs
);
371 if (count
> cupsArrayCount(devs
))
372 count
= cupsArrayCount(devs
);
374 for (dev
= (dev_info_t
*)cupsArrayFirst(devs
);
376 count
--, dev
= (dev_info_t
*)cupsArrayNext(devs
))
379 * Add strings to attributes...
382 cupsdSendIPPGroup(IPP_TAG_PRINTER
);
384 cupsdSendIPPString(IPP_TAG_KEYWORD
, "device-class", dev
->device_class
);
386 cupsdSendIPPString(IPP_TAG_TEXT
, "device-info", dev
->device_info
);
387 if (send_make_and_model
)
388 cupsdSendIPPString(IPP_TAG_TEXT
, "device-make-and-model",
389 dev
->device_make_and_model
);
391 cupsdSendIPPString(IPP_TAG_URI
, "device-uri", dev
->device_uri
);
393 cupsdSendIPPString(IPP_TAG_TEXT
, "device-id", dev
->device_id
);
396 cupsdSendIPPTrailer();
399 * Free the devices array and return...
402 for (dev
= (dev_info_t
*)cupsArrayFirst(devs
);
404 dev
= (dev_info_t
*)cupsArrayNext(devs
))
407 cupsArrayDelete(devs
);
414 * 'add_dev()' - Add a new device to the list.
417 static dev_info_t
* /* O - New device or NULL on error */
419 const char *device_class
, /* I - Device class */
420 const char *device_make_and_model
, /* I - Device make and model */
421 const char *device_info
, /* I - Device information */
422 const char *device_uri
, /* I - Device URI */
423 const char *device_id
) /* I - 1284 device ID */
425 dev_info_t
*dev
; /* New device */
429 * Allocate memory for the device record...
432 if ((dev
= calloc(1, sizeof(dev_info_t
))) == NULL
)
434 fputs("ERROR: [cups-deviced] Ran out of memory allocating a device!\n",
440 * Copy the strings over...
443 strlcpy(dev
->device_class
, device_class
, sizeof(dev
->device_class
));
444 strlcpy(dev
->device_make_and_model
, device_make_and_model
,
445 sizeof(dev
->device_make_and_model
));
446 strlcpy(dev
->device_info
, device_info
, sizeof(dev
->device_info
));
447 strlcpy(dev
->device_uri
, device_uri
, sizeof(dev
->device_uri
));
448 strlcpy(dev
->device_id
, device_id
, sizeof(dev
->device_id
));
451 * Add the device to the array and return...
454 cupsArrayAdd(devs
, dev
);
461 * 'compare_devs()' - Compare device names for sorting.
464 static int /* O - Result of comparison */
465 compare_devs(dev_info_t
*d0
, /* I - First device */
466 dev_info_t
*d1
) /* I - Second device */
468 int diff
; /* Difference between strings */
472 * Sort devices by device-info, device-class, and device-uri...
475 if ((diff
= cupsdCompareNames(d0
->device_info
, d1
->device_info
)) != 0)
477 else if ((diff
= strcasecmp(d0
->device_class
, d1
->device_class
)) != 0)
480 return (strcasecmp(d0
->device_uri
, d1
->device_uri
));
485 * 'sigalrm_handler()' - Handle alarm signals for backends that get hung
486 * trying to list the available devices...
490 sigalrm_handler(int sig
) /* I - Signal number */
492 (void)sig
; /* remove compiler warnings... */
499 * End of "$Id: cups-deviced.c 5099 2006-02-13 02:46:10Z mike $".