]>
git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/cups-deviced.c
2 * "$Id: cups-deviced.c 5044 2006-02-01 21:35:30Z mike $"
4 * Device scanning mini-daemon for the Common UNIX Printing System (CUPS).
6 * Copyright 1997-2005 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
);
133 cupsdSendIPPHeader(IPP_BAD_REQUEST
, request_id
);
134 cupsdSendIPPGroup(IPP_TAG_OPERATION
);
135 cupsdSendIPPString(IPP_TAG_CHARSET
, "attributes-charset", "utf-8");
136 cupsdSendIPPString(IPP_TAG_LANGUAGE
, "attributes-natural-language",
138 cupsdSendIPPString(IPP_TAG_TEXT
, "status-message",
139 "Bad command-line arguments passed to cups-deviced!");
140 cupsdSendIPPTrailer();
147 fprintf(stderr
, "cups-deviced: Bad request ID %d!\n", request_id
);
149 cupsdSendIPPHeader(IPP_BAD_REQUEST
, request_id
);
150 cupsdSendIPPGroup(IPP_TAG_OPERATION
);
151 cupsdSendIPPString(IPP_TAG_CHARSET
, "attributes-charset", "utf-8");
152 cupsdSendIPPString(IPP_TAG_LANGUAGE
, "attributes-natural-language",
154 cupsdSendIPPString(IPP_TAG_TEXT
, "status-message",
155 "Bad request ID argument passed to cups-deviced!");
156 cupsdSendIPPTrailer();
161 normal_user
= atoi(argv
[3]);
162 if (normal_user
<= 0)
164 fprintf(stderr
, "cups-deviced: Bad user %d!\n", normal_user
);
166 cupsdSendIPPHeader(IPP_BAD_REQUEST
, request_id
);
167 cupsdSendIPPGroup(IPP_TAG_OPERATION
);
168 cupsdSendIPPString(IPP_TAG_CHARSET
, "attributes-charset", "utf-8");
169 cupsdSendIPPString(IPP_TAG_LANGUAGE
, "attributes-natural-language",
171 cupsdSendIPPString(IPP_TAG_TEXT
, "status-message",
172 "Bad user ID argument passed to cups-deviced!");
173 cupsdSendIPPTrailer();
178 num_options
= cupsParseOptions(argv
[4], 0, &options
);
179 requested
= cupsGetOption("requested-attributes", num_options
, options
);
181 if (!requested
|| strstr(requested
, "all"))
185 send_make_and_model
= 1;
191 send_class
= strstr(requested
, "device-class") != NULL
;
192 send_info
= strstr(requested
, "device-info") != NULL
;
193 send_make_and_model
= strstr(requested
, "device-make-and-model") != NULL
;
194 send_uri
= strstr(requested
, "device-uri") != NULL
;
195 send_id
= strstr(requested
, "device-id") != NULL
;
199 * Try opening the backend directory...
202 if ((server_bin
= getenv("CUPS_SERVERBIN")) == NULL
)
203 server_bin
= CUPS_SERVERBIN
;
205 snprintf(backends
, sizeof(backends
), "%s/backend", server_bin
);
207 if ((dir
= cupsDirOpen(backends
)) == NULL
)
209 fprintf(stderr
, "ERROR: [cups-deviced] Unable to open backend directory "
210 "\"%s\": %s", backends
, strerror(errno
));
212 snprintf(line
, sizeof(line
), "Unable to open backend directory \"%s\": %s",
213 backends
, strerror(errno
));
214 cupsdSendIPPHeader(IPP_BAD_REQUEST
, request_id
);
215 cupsdSendIPPGroup(IPP_TAG_OPERATION
);
216 cupsdSendIPPString(IPP_TAG_CHARSET
, "attributes-charset", "utf-8");
217 cupsdSendIPPString(IPP_TAG_LANGUAGE
, "attributes-natural-language",
219 cupsdSendIPPString(IPP_TAG_TEXT
, "status-message", line
);
220 cupsdSendIPPTrailer();
226 * Setup the devices array...
229 devs
= cupsArrayNew((cups_array_func_t
)compare_devs
, NULL
);
232 * Loop through all of the device backends...
235 while ((dent
= cupsDirRead(dir
)) != NULL
)
238 * Skip entries that are not executable files...
241 if (!S_ISREG(dent
->fileinfo
.st_mode
) ||
242 (dent
->fileinfo
.st_mode
& (S_IRUSR
| S_IXUSR
)) != (S_IRUSR
| S_IXUSR
))
246 * Change effective users depending on the backend permissions...
252 * Backends without permissions for normal users run as root,
253 * all others run as the unprivileged user...
256 if (!(dent
->fileinfo
.st_mode
& (S_IRWXG
| S_IRWXO
)))
259 seteuid(normal_user
);
263 * Run the backend with no arguments and collect the output...
266 snprintf(filename
, sizeof(filename
), "%s/%s", backends
, dent
->filename
);
267 if ((fp
= popen(filename
, "r")) != NULL
)
270 * Set an alarm for the first read from the backend; this avoids
271 * problems when a backend is hung getting device information.
274 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
275 sigset(SIGALRM
, sigalrm_handler
);
276 #elif defined(HAVE_SIGACTION)
277 memset(&action
, 0, sizeof(action
));
279 sigemptyset(&action
.sa_mask
);
280 sigaddset(&action
.sa_mask
, SIGALRM
);
281 action
.sa_handler
= sigalrm_handler
;
282 sigaction(SIGALRM
, &action
, NULL
);
284 signal(SIGALRM
, sigalrm_handler
);
285 #endif /* HAVE_SIGSET */
289 compat
= !strcmp(dent
->filename
, "smb");
293 while (fgets(line
, sizeof(line
), fp
) != NULL
)
296 * Reset the alarm clock...
302 * Each line is of the form:
304 * class URI "make model" "name" ["1284 device ID"]
309 if (!strncasecmp(line
, "Usage", 5))
311 else if (sscanf(line
,
312 "%63s%1023s%*[ \t]\"%255[^\"]\"%*[ \t]\"%127[^\"]"
313 "%*[ \t]\"%1023[^\"]",
314 dclass
, uri
, make_model
, info
, device_id
) < 4)
317 * Bad format; strip trailing newline and write an error message.
320 if (line
[strlen(line
) - 1] == '\n')
321 line
[strlen(line
) - 1] = '\0';
323 fprintf(stderr
, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
324 dent
->filename
, line
);
331 * Add the device to the array of available devices...
334 dev
= add_dev(dclass
, make_model
, info
, uri
, device_id
);
341 fprintf(stderr
, "DEBUG: [cups-deviced] Added device \"%s\"...\n",
348 * Turn the alarm clock off and close the pipe to the command...
354 fprintf(stderr
, "WARNING: [cups-deviced] Backend \"%s\" did not "
355 "respond within 30 seconds!\n", dent
->filename
);
360 * Hack for backends that don't support the CUPS 1.1 calling convention:
361 * add a network device with the method == backend name.
364 if (count
== 0 && compat
)
366 snprintf(line
, sizeof(line
), "Unknown Network Device (%s)",
369 dev
= add_dev("network", line
, "Unknown", dent
->filename
, "");
376 fprintf(stderr
, "DEBUG: [cups-deviced] Compatibility device "
377 "\"%s\"...\n", dent
->filename
);
381 fprintf(stderr
, "WARNING: [cups-deviced] Unable to execute \"%s\" "
382 "backend: %s\n", dent
->filename
, strerror(errno
));
388 * Switch back to root as needed...
391 if (!getuid() && geteuid())
395 * Output the list of devices...
398 puts("Content-Type: application/ipp\n");
400 cupsdSendIPPHeader(IPP_OK
, request_id
);
401 cupsdSendIPPGroup(IPP_TAG_OPERATION
);
402 cupsdSendIPPString(IPP_TAG_CHARSET
, "attributes-charset", "utf-8");
403 cupsdSendIPPString(IPP_TAG_LANGUAGE
, "attributes-natural-language", "en-US");
405 if ((count
= atoi(argv
[2])) <= 0)
406 count
= cupsArrayCount(devs
);
408 if (count
> cupsArrayCount(devs
))
409 count
= cupsArrayCount(devs
);
411 for (dev
= (dev_info_t
*)cupsArrayFirst(devs
);
413 count
--, dev
= (dev_info_t
*)cupsArrayNext(devs
))
416 * Add strings to attributes...
419 cupsdSendIPPGroup(IPP_TAG_PRINTER
);
421 cupsdSendIPPString(IPP_TAG_KEYWORD
, "device-class", dev
->device_class
);
423 cupsdSendIPPString(IPP_TAG_TEXT
, "device-info", dev
->device_info
);
424 if (send_make_and_model
)
425 cupsdSendIPPString(IPP_TAG_TEXT
, "device-make-and-model",
426 dev
->device_make_and_model
);
428 cupsdSendIPPString(IPP_TAG_URI
, "device-uri", dev
->device_uri
);
430 cupsdSendIPPString(IPP_TAG_TEXT
, "device-id", dev
->device_id
);
433 cupsdSendIPPTrailer();
436 * Free the devices array and return...
439 for (dev
= (dev_info_t
*)cupsArrayFirst(devs
);
441 dev
= (dev_info_t
*)cupsArrayNext(devs
))
444 cupsArrayDelete(devs
);
451 * 'add_dev()' - Add a new device to the list.
454 static dev_info_t
* /* O - New device or NULL on error */
456 const char *device_class
, /* I - Device class */
457 const char *device_make_and_model
, /* I - Device make and model */
458 const char *device_info
, /* I - Device information */
459 const char *device_uri
, /* I - Device URI */
460 const char *device_id
) /* I - 1284 device ID */
462 dev_info_t
*dev
; /* New device */
466 * Allocate memory for the device record...
469 if ((dev
= calloc(1, sizeof(dev_info_t
))) == NULL
)
471 fputs("ERROR: [cups-deviced] Ran out of memory allocating a device!\n",
477 * Copy the strings over...
480 strlcpy(dev
->device_class
, device_class
, sizeof(dev
->device_class
));
481 strlcpy(dev
->device_make_and_model
, device_make_and_model
,
482 sizeof(dev
->device_make_and_model
));
483 strlcpy(dev
->device_info
, device_info
, sizeof(dev
->device_info
));
484 strlcpy(dev
->device_uri
, device_uri
, sizeof(dev
->device_uri
));
485 strlcpy(dev
->device_id
, device_id
, sizeof(dev
->device_id
));
488 * Add the device to the array and return...
491 cupsArrayAdd(devs
, dev
);
498 * 'compare_devs()' - Compare device names for sorting.
501 static int /* O - Result of comparison */
502 compare_devs(dev_info_t
*d0
, /* I - First device */
503 dev_info_t
*d1
) /* I - Second device */
505 int diff
; /* Difference between strings */
509 * Sort devices by device-info, device-class, and device-uri...
512 if ((diff
= cupsdCompareNames(d0
->device_info
, d1
->device_info
)) != 0)
514 else if ((diff
= strcasecmp(d0
->device_class
, d1
->device_class
)) != 0)
517 return (strcasecmp(d0
->device_uri
, d1
->device_uri
));
522 * 'sigalrm_handler()' - Handle alarm signals for backends that get hung
523 * trying to list the available devices...
527 sigalrm_handler(int sig
) /* I - Signal number */
529 (void)sig
; /* remove compiler warnings... */
536 * End of "$Id: cups-deviced.c 5044 2006-02-01 21:35:30Z mike $".