]> git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/cups-deviced.c
The debug strings table for mime type operations was out of sync with the
[thirdparty/cups.git] / scheduler / cups-deviced.c
1 /*
2 * "$Id$"
3 *
4 * Device scanning mini-daemon for CUPS.
5 *
6 * Copyright 2007-2014 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
16 /*
17 * Include necessary headers...
18 */
19
20 #include "util.h"
21 #include <cups/array.h>
22 #include <cups/dir.h>
23 #include <fcntl.h>
24 #include <sys/wait.h>
25 #include <poll.h>
26
27
28 /*
29 * Constants...
30 */
31
32 #define MAX_BACKENDS 200 /* Maximum number of backends we'll run */
33
34
35 /*
36 * Backend information...
37 */
38
39 typedef struct
40 {
41 char *name; /* Name of backend */
42 int pid, /* Process ID */
43 status; /* Exit status */
44 cups_file_t *pipe; /* Pipe from backend stdout */
45 int count; /* Number of devices found */
46 } cupsd_backend_t;
47
48
49 /*
50 * Device information structure...
51 */
52
53 typedef struct
54 {
55 char device_class[128], /* Device class */
56 device_info[128], /* Device info/description */
57 device_uri[1024]; /* Device URI */
58 } cupsd_device_t;
59
60
61 /*
62 * Local globals...
63 */
64
65 static int num_backends = 0,
66 /* Total backends */
67 active_backends = 0;
68 /* Active backends */
69 static cupsd_backend_t backends[MAX_BACKENDS];
70 /* Array of backends */
71 static struct pollfd backend_fds[MAX_BACKENDS];
72 /* Array for poll() */
73 static cups_array_t *devices; /* Array of devices */
74 static uid_t normal_user; /* Normal user ID */
75 static int device_limit; /* Maximum number of devices */
76 static int send_class, /* Send device-class attribute? */
77 send_info, /* Send device-info attribute? */
78 send_make_and_model,
79 /* Send device-make-and-model attribute? */
80 send_uri, /* Send device-uri attribute? */
81 send_id, /* Send device-id attribute? */
82 send_location; /* Send device-location attribute? */
83 static int dead_children = 0;
84 /* Dead children? */
85
86
87 /*
88 * Local functions...
89 */
90
91 static int add_device(const char *device_class,
92 const char *device_make_and_model,
93 const char *device_info,
94 const char *device_uri,
95 const char *device_id,
96 const char *device_location);
97 static int compare_devices(cupsd_device_t *p0,
98 cupsd_device_t *p1);
99 static double get_current_time(void);
100 static int get_device(cupsd_backend_t *backend);
101 static void process_children(void);
102 static void sigchld_handler(int sig);
103 static int start_backend(const char *backend, int root);
104
105
106 /*
107 * 'main()' - Scan for devices and return an IPP response.
108 *
109 * Usage:
110 *
111 * cups-deviced request_id limit options
112 */
113
114 int /* O - Exit code */
115 main(int argc, /* I - Number of command-line args */
116 char *argv[]) /* I - Command-line arguments */
117 {
118 int i; /* Looping var */
119 int request_id; /* Request ID */
120 int timeout; /* Timeout in seconds */
121 const char *server_bin; /* CUPS_SERVERBIN environment variable */
122 char filename[1024]; /* Backend directory filename */
123 cups_dir_t *dir; /* Directory pointer */
124 cups_dentry_t *dent; /* Directory entry */
125 double current_time, /* Current time */
126 end_time; /* Ending time */
127 int num_options; /* Number of options */
128 cups_option_t *options; /* Options */
129 cups_array_t *requested, /* requested-attributes values */
130 *exclude, /* exclude-schemes values */
131 *include; /* include-schemes values */
132 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
133 struct sigaction action; /* Actions for POSIX signals */
134 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
135
136
137 setbuf(stderr, NULL);
138
139 /*
140 * Check the command-line...
141 */
142
143 if (argc != 6)
144 {
145 fputs("Usage: cups-deviced request-id limit timeout user-id options\n", stderr);
146
147 return (1);
148 }
149
150 request_id = atoi(argv[1]);
151 if (request_id < 1)
152 {
153 fprintf(stderr, "ERROR: [cups-deviced] Bad request ID %d!\n", request_id);
154
155 return (1);
156 }
157
158 device_limit = atoi(argv[2]);
159 if (device_limit < 0)
160 {
161 fprintf(stderr, "ERROR: [cups-deviced] Bad limit %d!\n", device_limit);
162
163 return (1);
164 }
165
166 timeout = atoi(argv[3]);
167 if (timeout < 1)
168 {
169 fprintf(stderr, "ERROR: [cups-deviced] Bad timeout %d!\n", timeout);
170
171 return (1);
172 }
173
174 normal_user = (uid_t)atoi(argv[4]);
175 if (normal_user <= 0)
176 {
177 fprintf(stderr, "ERROR: [cups-deviced] Bad user %d!\n", normal_user);
178
179 return (1);
180 }
181
182 num_options = cupsParseOptions(argv[5], 0, &options);
183 requested = cupsdCreateStringsArray(cupsGetOption("requested-attributes",
184 num_options, options));
185 exclude = cupsdCreateStringsArray(cupsGetOption("exclude-schemes",
186 num_options, options));
187 include = cupsdCreateStringsArray(cupsGetOption("include-schemes",
188 num_options, options));
189
190 if (!requested || cupsArrayFind(requested, "all") != NULL)
191 {
192 send_class = send_info = send_make_and_model = send_uri = send_id =
193 send_location = 1;
194 }
195 else
196 {
197 send_class = cupsArrayFind(requested, "device-class") != NULL;
198 send_info = cupsArrayFind(requested, "device-info") != NULL;
199 send_make_and_model = cupsArrayFind(requested, "device-make-and-model") != NULL;
200 send_uri = cupsArrayFind(requested, "device-uri") != NULL;
201 send_id = cupsArrayFind(requested, "device-id") != NULL;
202 send_location = cupsArrayFind(requested, "device-location") != NULL;
203 }
204
205 /*
206 * Listen to child signals...
207 */
208
209 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
210 sigset(SIGCHLD, sigchld_handler);
211 #elif defined(HAVE_SIGACTION)
212 memset(&action, 0, sizeof(action));
213
214 sigemptyset(&action.sa_mask);
215 sigaddset(&action.sa_mask, SIGCHLD);
216 action.sa_handler = sigchld_handler;
217 sigaction(SIGCHLD, &action, NULL);
218 #else
219 signal(SIGCLD, sigchld_handler); /* No, SIGCLD isn't a typo... */
220 #endif /* HAVE_SIGSET */
221
222 /*
223 * Try opening the backend directory...
224 */
225
226 if ((server_bin = getenv("CUPS_SERVERBIN")) == NULL)
227 server_bin = CUPS_SERVERBIN;
228
229 snprintf(filename, sizeof(filename), "%s/backend", server_bin);
230
231 if ((dir = cupsDirOpen(filename)) == NULL)
232 {
233 fprintf(stderr, "ERROR: [cups-deviced] Unable to open backend directory "
234 "\"%s\": %s", filename, strerror(errno));
235
236 return (1);
237 }
238
239 /*
240 * Setup the devices array...
241 */
242
243 devices = cupsArrayNew((cups_array_func_t)compare_devices, NULL);
244
245 /*
246 * Loop through all of the device backends...
247 */
248
249 while ((dent = cupsDirRead(dir)) != NULL)
250 {
251 /*
252 * Skip entries that are not executable files...
253 */
254
255 if (!S_ISREG(dent->fileinfo.st_mode) ||
256 !isalnum(dent->filename[0] & 255) ||
257 (dent->fileinfo.st_mode & (S_IRUSR | S_IXUSR)) != (S_IRUSR | S_IXUSR))
258 continue;
259
260 /*
261 * Skip excluded or not included backends...
262 */
263
264 if (cupsArrayFind(exclude, dent->filename) ||
265 (include && !cupsArrayFind(include, dent->filename)))
266 continue;
267
268 /*
269 * Backends without permissions for normal users run as root,
270 * all others run as the unprivileged user...
271 */
272
273 start_backend(dent->filename, !(dent->fileinfo.st_mode & (S_IWGRP | S_IRWXO)));
274 }
275
276 cupsDirClose(dir);
277
278 /*
279 * Collect devices...
280 */
281
282 if (getenv("SOFTWARE"))
283 puts("Content-Type: application/ipp\n");
284
285 cupsdSendIPPHeader(IPP_OK, request_id);
286 cupsdSendIPPGroup(IPP_TAG_OPERATION);
287 cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
288 cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language", "en-US");
289
290 end_time = get_current_time() + timeout;
291
292 while (active_backends > 0 && (current_time = get_current_time()) < end_time)
293 {
294 /*
295 * Collect the output from the backends...
296 */
297
298 timeout = (int)(1000 * (end_time - current_time));
299
300 if (poll(backend_fds, (nfds_t)num_backends, timeout) > 0)
301 {
302 for (i = 0; i < num_backends; i ++)
303 if (backend_fds[i].revents && backends[i].pipe)
304 {
305 cups_file_t *bpipe = backends[i].pipe;
306 /* Copy of pipe for backend... */
307
308 do
309 {
310 if (get_device(backends + i))
311 {
312 backend_fds[i].fd = 0;
313 backend_fds[i].events = 0;
314 break;
315 }
316 }
317 while (bpipe->ptr && memchr(bpipe->ptr, '\n', (size_t)(bpipe->end - bpipe->ptr)));
318 }
319 }
320
321 /*
322 * Get exit status from children...
323 */
324
325 if (dead_children)
326 process_children();
327 }
328
329 cupsdSendIPPTrailer();
330
331 /*
332 * Terminate any remaining backends and exit...
333 */
334
335 if (active_backends > 0)
336 {
337 for (i = 0; i < num_backends; i ++)
338 if (backends[i].pid)
339 kill(backends[i].pid, SIGTERM);
340 }
341
342 return (0);
343 }
344
345
346 /*
347 * 'add_device()' - Add a new device to the list.
348 */
349
350 static int /* O - 0 on success, -1 on error */
351 add_device(
352 const char *device_class, /* I - Device class */
353 const char *device_make_and_model, /* I - Device make and model */
354 const char *device_info, /* I - Device information */
355 const char *device_uri, /* I - Device URI */
356 const char *device_id, /* I - 1284 device ID */
357 const char *device_location) /* I - Physical location */
358 {
359 cupsd_device_t *device; /* New device */
360
361
362 /*
363 * Allocate memory for the device record...
364 */
365
366 if ((device = calloc(1, sizeof(cupsd_device_t))) == NULL)
367 {
368 fputs("ERROR: [cups-deviced] Ran out of memory allocating a device!\n",
369 stderr);
370 return (-1);
371 }
372
373 /*
374 * Copy the strings over...
375 */
376
377 strlcpy(device->device_class, device_class, sizeof(device->device_class));
378 strlcpy(device->device_info, device_info, sizeof(device->device_info));
379 strlcpy(device->device_uri, device_uri, sizeof(device->device_uri));
380
381 /*
382 * Add the device to the array and return...
383 */
384
385 if (cupsArrayFind(devices, device))
386 {
387 /*
388 * Avoid duplicates!
389 */
390
391 free(device);
392 }
393 else
394 {
395 cupsArrayAdd(devices, device);
396
397 if (device_limit <= 0 || cupsArrayCount(devices) < device_limit)
398 {
399 /*
400 * Send device info...
401 */
402
403 cupsdSendIPPGroup(IPP_TAG_PRINTER);
404 if (send_class)
405 cupsdSendIPPString(IPP_TAG_KEYWORD, "device-class",
406 device_class);
407 if (send_info)
408 cupsdSendIPPString(IPP_TAG_TEXT, "device-info", device_info);
409 if (send_make_and_model)
410 cupsdSendIPPString(IPP_TAG_TEXT, "device-make-and-model",
411 device_make_and_model);
412 if (send_uri)
413 cupsdSendIPPString(IPP_TAG_URI, "device-uri", device_uri);
414 if (send_id)
415 cupsdSendIPPString(IPP_TAG_TEXT, "device-id",
416 device_id ? device_id : "");
417 if (send_location)
418 cupsdSendIPPString(IPP_TAG_TEXT, "device-location",
419 device_location ? device_location : "");
420
421 fflush(stdout);
422 fputs("DEBUG: Flushed attributes...\n", stderr);
423 }
424 }
425
426 return (0);
427 }
428
429
430 /*
431 * 'compare_devices()' - Compare device names to eliminate duplicates.
432 */
433
434 static int /* O - Result of comparison */
435 compare_devices(cupsd_device_t *d0, /* I - First device */
436 cupsd_device_t *d1) /* I - Second device */
437 {
438 int diff; /* Difference between strings */
439
440
441 /*
442 * Sort devices by device-info, device-class, and device-uri...
443 */
444
445 if ((diff = cupsdCompareNames(d0->device_info, d1->device_info)) != 0)
446 return (diff);
447 else if ((diff = _cups_strcasecmp(d0->device_class, d1->device_class)) != 0)
448 return (diff);
449 else
450 return (_cups_strcasecmp(d0->device_uri, d1->device_uri));
451 }
452
453
454 /*
455 * 'get_current_time()' - Get the current time as a double value in seconds.
456 */
457
458 static double /* O - Time in seconds */
459 get_current_time(void)
460 {
461 struct timeval curtime; /* Current time */
462
463
464 gettimeofday(&curtime, NULL);
465
466 return (curtime.tv_sec + 0.000001 * curtime.tv_usec);
467 }
468
469
470 /*
471 * 'get_device()' - Get a device from a backend.
472 */
473
474 static int /* O - 0 on success, -1 on error */
475 get_device(cupsd_backend_t *backend) /* I - Backend to read from */
476 {
477 char line[2048], /* Line from backend */
478 temp[2048], /* Copy of line */
479 *ptr, /* Pointer into line */
480 *dclass, /* Device class */
481 *uri, /* Device URI */
482 *make_model, /* Make and model */
483 *info, /* Device info */
484 *device_id, /* 1284 device ID */
485 *location; /* Physical location */
486
487
488 if (cupsFileGets(backend->pipe, line, sizeof(line)))
489 {
490 /*
491 * Each line is of the form:
492 *
493 * class URI "make model" "name" ["1284 device ID"] ["location"]
494 */
495
496 strlcpy(temp, line, sizeof(temp));
497
498 /*
499 * device-class
500 */
501
502 dclass = temp;
503
504 for (ptr = temp; *ptr; ptr ++)
505 if (isspace(*ptr & 255))
506 break;
507
508 while (isspace(*ptr & 255))
509 *ptr++ = '\0';
510
511 /*
512 * device-uri
513 */
514
515 if (!*ptr)
516 goto error;
517
518 for (uri = ptr; *ptr; ptr ++)
519 if (isspace(*ptr & 255))
520 break;
521
522 while (isspace(*ptr & 255))
523 *ptr++ = '\0';
524
525 /*
526 * device-make-and-model
527 */
528
529 if (*ptr != '\"')
530 goto error;
531
532 for (ptr ++, make_model = ptr; *ptr && *ptr != '\"'; ptr ++)
533 {
534 if (*ptr == '\\' && ptr[1])
535 _cups_strcpy(ptr, ptr + 1);
536 }
537
538 if (*ptr != '\"')
539 goto error;
540
541 for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0');
542
543 /*
544 * device-info
545 */
546
547 if (*ptr != '\"')
548 goto error;
549
550 for (ptr ++, info = ptr; *ptr && *ptr != '\"'; ptr ++)
551 {
552 if (*ptr == '\\' && ptr[1])
553 _cups_strcpy(ptr, ptr + 1);
554 }
555
556 if (*ptr != '\"')
557 goto error;
558
559 for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0');
560
561 /*
562 * device-id
563 */
564
565 if (*ptr == '\"')
566 {
567 for (ptr ++, device_id = ptr; *ptr && *ptr != '\"'; ptr ++)
568 {
569 if (*ptr == '\\' && ptr[1])
570 _cups_strcpy(ptr, ptr + 1);
571 }
572
573 if (*ptr != '\"')
574 goto error;
575
576 for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0');
577
578 /*
579 * device-location
580 */
581
582 if (*ptr == '\"')
583 {
584 for (ptr ++, location = ptr; *ptr && *ptr != '\"'; ptr ++)
585 {
586 if (*ptr == '\\' && ptr[1])
587 _cups_strcpy(ptr, ptr + 1);
588 }
589
590 if (*ptr != '\"')
591 goto error;
592
593 *ptr = '\0';
594 }
595 else
596 location = NULL;
597 }
598 else
599 {
600 device_id = NULL;
601 location = NULL;
602 }
603
604 /*
605 * Add the device to the array of available devices...
606 */
607
608 if (!add_device(dclass, make_model, info, uri, device_id, location))
609 fprintf(stderr, "DEBUG: [cups-deviced] Found device \"%s\"...\n", uri);
610
611 return (0);
612 }
613
614 /*
615 * End of file...
616 */
617
618 cupsFileClose(backend->pipe);
619 backend->pipe = NULL;
620
621 return (-1);
622
623 /*
624 * Bad format; strip trailing newline and write an error message.
625 */
626
627 error:
628
629 if (line[strlen(line) - 1] == '\n')
630 line[strlen(line) - 1] = '\0';
631
632 fprintf(stderr, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
633 backend->name, line);
634 return (0);
635 }
636
637
638 /*
639 * 'process_children()' - Process all dead children...
640 */
641
642 static void
643 process_children(void)
644 {
645 int i; /* Looping var */
646 int status; /* Exit status of child */
647 int pid; /* Process ID of child */
648 cupsd_backend_t *backend; /* Current backend */
649 const char *name; /* Name of process */
650
651
652 /*
653 * Reset the dead_children flag...
654 */
655
656 dead_children = 0;
657
658 /*
659 * Collect the exit status of some children...
660 */
661
662 #ifdef HAVE_WAITPID
663 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
664 #elif defined(HAVE_WAIT3)
665 while ((pid = wait3(&status, WNOHANG, NULL)) > 0)
666 #else
667 if ((pid = wait(&status)) > 0)
668 #endif /* HAVE_WAITPID */
669 {
670 if (status == SIGTERM)
671 status = 0;
672
673 for (i = num_backends, backend = backends; i > 0; i --, backend ++)
674 if (backend->pid == pid)
675 break;
676
677 if (i > 0)
678 {
679 name = backend->name;
680 backend->pid = 0;
681 backend->status = status;
682
683 active_backends --;
684 }
685 else
686 name = "Unknown";
687
688 if (status)
689 {
690 if (WIFEXITED(status))
691 fprintf(stderr,
692 "ERROR: [cups-deviced] PID %d (%s) stopped with status %d!\n",
693 pid, name, WEXITSTATUS(status));
694 else
695 fprintf(stderr,
696 "ERROR: [cups-deviced] PID %d (%s) crashed on signal %d!\n",
697 pid, name, WTERMSIG(status));
698 }
699 else
700 fprintf(stderr,
701 "DEBUG: [cups-deviced] PID %d (%s) exited with no errors.\n",
702 pid, name);
703 }
704 }
705
706
707 /*
708 * 'sigchld_handler()' - Handle 'child' signals from old processes.
709 */
710
711 static void
712 sigchld_handler(int sig) /* I - Signal number */
713 {
714 (void)sig;
715
716 /*
717 * Flag that we have dead children...
718 */
719
720 dead_children = 1;
721
722 /*
723 * Reset the signal handler as needed...
724 */
725
726 #if !defined(HAVE_SIGSET) && !defined(HAVE_SIGACTION)
727 signal(SIGCLD, sigchld_handler);
728 #endif /* !HAVE_SIGSET && !HAVE_SIGACTION */
729 }
730
731
732 /*
733 * 'start_backend()' - Run a backend to gather the available devices.
734 */
735
736 static int /* O - 0 on success, -1 on error */
737 start_backend(const char *name, /* I - Backend to run */
738 int root) /* I - Run as root? */
739 {
740 const char *server_bin; /* CUPS_SERVERBIN environment variable */
741 char program[1024]; /* Full path to backend */
742 cupsd_backend_t *backend; /* Current backend */
743 char *argv[2]; /* Command-line arguments */
744
745
746 if (num_backends >= MAX_BACKENDS)
747 {
748 fprintf(stderr, "ERROR: Too many backends (%d)!\n", num_backends);
749 return (-1);
750 }
751
752 if ((server_bin = getenv("CUPS_SERVERBIN")) == NULL)
753 server_bin = CUPS_SERVERBIN;
754
755 snprintf(program, sizeof(program), "%s/backend/%s", server_bin, name);
756
757 if (_cupsFileCheck(program, _CUPS_FILE_CHECK_PROGRAM, !geteuid(),
758 _cupsFileCheckFilter, NULL))
759 return (-1);
760
761 backend = backends + num_backends;
762
763 argv[0] = (char *)name;
764 argv[1] = NULL;
765
766 if ((backend->pipe = cupsdPipeCommand(&(backend->pid), program, argv,
767 root ? 0 : normal_user)) == NULL)
768 {
769 fprintf(stderr, "ERROR: [cups-deviced] Unable to execute \"%s\" - %s\n",
770 program, strerror(errno));
771 return (-1);
772 }
773
774 /*
775 * Fill in the rest of the backend information...
776 */
777
778 fprintf(stderr, "DEBUG: [cups-deviced] Started backend %s (PID %d)\n",
779 program, backend->pid);
780
781 backend_fds[num_backends].fd = cupsFileNumber(backend->pipe);
782 backend_fds[num_backends].events = POLLIN;
783
784 backend->name = strdup(name);
785 backend->status = 0;
786 backend->count = 0;
787
788 active_backends ++;
789 num_backends ++;
790
791 return (0);
792 }
793
794
795 /*
796 * End of "$Id$".
797 */