]> git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/main.c
projects / thirdparty / cups.git / blob
? search:


76e095bfdbcec5a5c28edaf85db5820b9d61e24d
[thirdparty/cups.git] / scheduler / main.c
1 /*
2 * "$Id: main.c 12248 2014-11-12 16:32:57Z msweet $"
3 *
4 * Main loop for the CUPS scheduler.
5 *
6 * Copyright 2007-2014 by Apple Inc.
7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
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 * "LICENSE" which should have been included with this file. If this
13 * file is missing or damaged, see the license at "http://www.cups.org/".
14 */
15
16 /*
17 * Include necessary headers...
18 */
19
20 #define _MAIN_C_
21 #include "cupsd.h"
22 #include <sys/resource.h>
23 #include <syslog.h>
24 #include <grp.h>
25
26 #ifdef HAVE_LAUNCH_H
27 # include <launch.h>
28 # include <libgen.h>
29 # define CUPS_KEEPALIVE CUPS_CACHEDIR "/org.cups.cupsd"
30 /* Name of the launchd KeepAlive file */
31 # ifdef HAVE_LAUNCH_ACTIVATE_SOCKET
32 /* Update when we have a public header we can include */
33 extern int launch_activate_socket(const char *name, int **fds, size_t *cnt);
34 # endif /* HAVE_LAUNCH_ACTIVATE_SOCKET */
35 #endif /* HAVE_LAUNCH_H */
36
37 #ifdef HAVE_SYSTEMD
38 # include <systemd/sd-daemon.h>
39 # define CUPS_KEEPALIVE CUPS_CACHEDIR "/org.cups.cupsd"
40 /* Name of the systemd path file */
41 #endif /* HAVE_SYSTEMD */
42
43 #if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO)
44 # include <malloc.h>
45 #endif /* HAVE_MALLOC_H && HAVE_MALLINFO */
46
47 #ifdef HAVE_NOTIFY_H
48 # include <notify.h>
49 #endif /* HAVE_NOTIFY_H */
50
51 #ifdef HAVE_DBUS
52 # include <dbus/dbus.h>
53 #endif /* HAVE_DBUS */
54
55 #ifdef HAVE_SYS_PARAM_H
56 # include <sys/param.h>
57 #endif /* HAVE_SYS_PARAM_H */
58
59
60 /*
61 * Local functions...
62 */
63
64 static void parent_handler(int sig);
65 static void process_children(void);
66 static void sigchld_handler(int sig);
67 static void sighup_handler(int sig);
68 static void sigterm_handler(int sig);
69 static long select_timeout(int fds);
70 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
71 static void service_checkin(void);
72 static void service_checkout(void);
73 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
74 static void usage(int status) __attribute__((noreturn));
75
76
77 /*
78 * Local globals...
79 */
80
81 static int parent_signal = 0;
82 /* Set to signal number from child */
83 static int holdcount = 0; /* Number of times "hold" was called */
84 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
85 static sigset_t holdmask; /* Old POSIX signal mask */
86 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
87 static int dead_children = 0;
88 /* Dead children? */
89 static int stop_scheduler = 0;
90 /* Should the scheduler stop? */
91
92
93 /*
94 * 'main()' - Main entry for the CUPS scheduler.
95 */
96
97 int /* O - Exit status */
98 main(int argc, /* I - Number of command-line args */
99 char *argv[]) /* I - Command-line arguments */
100 {
101 int i; /* Looping var */
102 char *opt; /* Option character */
103 int close_all = 1, /* Close all file descriptors? */
104 disconnect = 1, /* Disconnect from controlling terminal? */
105 fg = 0, /* Run in foreground? */
106 run_as_child = 0;
107 /* Running as child process? */
108 int fds; /* Number of ready descriptors */
109 cupsd_client_t *con; /* Current client */
110 cupsd_job_t *job; /* Current job */
111 cupsd_listener_t *lis; /* Current listener */
112 time_t current_time, /* Current time */
113 activity, /* Client activity timer */
114 senddoc_time, /* Send-Document time */
115 expire_time, /* Subscription expire time */
116 report_time, /* Malloc/client/job report time */
117 event_time; /* Last event notification time */
118 long timeout; /* Timeout for cupsdDoSelect() */
119 struct rlimit limit; /* Runtime limit */
120 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
121 struct sigaction action; /* Actions for POSIX signals */
122 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
123 #ifdef __APPLE__
124 int use_sysman = 1; /* Use system management functions? */
125 #else
126 time_t netif_time = 0; /* Time since last network update */
127 #endif /* __APPLE__ */
128 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
129 int service_idle_exit;
130 /* Idle exit on select timeout? */
131 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
132
133
134 #ifdef HAVE_GETEUID
135 /*
136 * Check for setuid invocation, which we do not support!
137 */
138
139 if (getuid() != geteuid())
140 {
141 fputs("cupsd: Cannot run as a setuid program.\n", stderr);
142 return (1);
143 }
144 #endif /* HAVE_GETEUID */
145
146 /*
147 * Check for command-line arguments...
148 */
149
150 fg = 0;
151
152 #ifdef HAVE_LAUNCHD
153 if (getenv("CUPSD_LAUNCHD"))
154 {
155 OnDemand = 1;
156 fg = 1;
157 close_all = 0;
158 disconnect = 0;
159 }
160 #endif /* HAVE_LAUNCHD */
161
162 for (i = 1; i < argc; i ++)
163 if (argv[i][0] == '-')
164 for (opt = argv[i] + 1; *opt != '\0'; opt ++)
165 switch (*opt)
166 {
167 case 'C' : /* Run as child with config file */
168 run_as_child = 1;
169 fg = 1;
170 close_all = 0;
171
172 case 'c' : /* Configuration file */
173 i ++;
174 if (i >= argc)
175 {
176 _cupsLangPuts(stderr, _("cupsd: Expected config filename "
177 "after \"-c\" option."));
178 usage(1);
179 }
180
181 if (argv[i][0] == '/')
182 {
183 /*
184 * Absolute directory...
185 */
186
187 cupsdSetString(&ConfigurationFile, argv[i]);
188 }
189 else
190 {
191 /*
192 * Relative directory...
193 */
194
195 char *current; /* Current directory */
196
197 /*
198 * Allocate a buffer for the current working directory to
199 * reduce run-time stack usage; this approximates the
200 * behavior of some implementations of getcwd() when they
201 * are passed a NULL pointer.
202 */
203
204 if ((current = malloc(1024)) == NULL)
205 {
206 _cupsLangPuts(stderr,
207 _("cupsd: Unable to get current directory."));
208 return (1);
209 }
210
211 if (!getcwd(current, 1024))
212 {
213 _cupsLangPuts(stderr,
214 _("cupsd: Unable to get current directory."));
215 free(current);
216 return (1);
217 }
218
219 cupsdSetStringf(&ConfigurationFile, "%s/%s", current, argv[i]);
220 free(current);
221 }
222 break;
223
224 case 'f' : /* Run in foreground... */
225 fg = 1;
226 disconnect = 0;
227 close_all = 0;
228 break;
229
230 case 'F' : /* Run in foreground, but disconnect from terminal... */
231 fg = 1;
232 close_all = 0;
233 break;
234
235 case 'h' : /* Show usage/help */
236 usage(0);
237 break;
238
239 case 'l' : /* Started by launchd/systemd... */
240 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
241 OnDemand = 1;
242 fg = 1;
243 close_all = 0;
244 disconnect = 0;
245 #else
246 _cupsLangPuts(stderr, _("cupsd: On-demand support not compiled "
247 "in, running in normal mode."));
248 fg = 0;
249 disconnect = 1;
250 close_all = 1;
251 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
252 break;
253
254 case 'p' : /* Stop immediately for profiling */
255 fputs("cupsd: -p (startup profiling) is for internal testing "
256 "use only!\n", stderr);
257 stop_scheduler = 1;
258 fg = 1;
259 disconnect = 0;
260 close_all = 0;
261 break;
262
263 case 'P' : /* Disable security profiles */
264 fputs("cupsd: -P (disable sandboxing) is for internal testing use only.\n", stderr);
265 UseSandboxing = 0;
266 break;
267
268 case 's' : /* Set cups-files.conf location */
269 i ++;
270 if (i >= argc)
271 {
272 _cupsLangPuts(stderr, _("cupsd: Expected cups-files.conf "
273 "filename after \"-s\" option."));
274 usage(1);
275 }
276
277 if (argv[i][0] != '/')
278 {
279 /*
280 * Relative filename not allowed...
281 */
282
283 _cupsLangPuts(stderr, _("cupsd: Relative cups-files.conf "
284 "filename not allowed."));
285 usage(1);
286 }
287
288 cupsdSetString(&CupsFilesFile, argv[i]);
289 break;
290
291 #ifdef __APPLE__
292 case 'S' : /* Disable system management functions */
293 fputs("cupsd: -S (disable system management) for internal "
294 "testing use only!\n", stderr);
295 use_sysman = 0;
296 break;
297 #endif /* __APPLE__ */
298
299 case 't' : /* Test the cupsd.conf file... */
300 TestConfigFile = 1;
301 fg = 1;
302 disconnect = 0;
303 close_all = 0;
304 break;
305
306 default : /* Unknown option */
307 _cupsLangPrintf(stderr, _("cupsd: Unknown option \"%c\" - "
308 "aborting."), *opt);
309 usage(1);
310 break;
311 }
312 else
313 {
314 _cupsLangPrintf(stderr, _("cupsd: Unknown argument \"%s\" - aborting."),
315 argv[i]);
316 usage(1);
317 }
318
319 if (!ConfigurationFile)
320 cupsdSetString(&ConfigurationFile, CUPS_SERVERROOT "/cupsd.conf");
321
322 if (!CupsFilesFile)
323 {
324 char *filename, /* Copy of cupsd.conf filename */
325 *slash; /* Final slash in cupsd.conf filename */
326 size_t len; /* Size of buffer */
327
328 len = strlen(ConfigurationFile) + 15;
329 if ((filename = malloc(len)) == NULL)
330 {
331 _cupsLangPrintf(stderr,
332 _("cupsd: Unable to get path to "
333 "cups-files.conf file."));
334 return (1);
335 }
336
337 strlcpy(filename, ConfigurationFile, len);
338 if ((slash = strrchr(filename, '/')) == NULL)
339 {
340 _cupsLangPrintf(stderr,
341 _("cupsd: Unable to get path to "
342 "cups-files.conf file."));
343 return (1);
344 }
345
346 strlcpy(slash, "/cups-files.conf", len - (size_t)(slash - filename));
347 cupsdSetString(&CupsFilesFile, filename);
348 free(filename);
349 }
350
351 if (disconnect)
352 {
353 /*
354 * Make sure we aren't tying up any filesystems...
355 */
356
357 chdir("/");
358
359 /*
360 * Disconnect from the controlling terminal...
361 */
362
363 setsid();
364 }
365
366 if (close_all)
367 {
368 /*
369 * Close all open files...
370 */
371
372 getrlimit(RLIMIT_NOFILE, &limit);
373
374 for (i = 0; i < (int)limit.rlim_cur && i < 1024; i ++)
375 close(i);
376
377 /*
378 * Redirect stdin/out/err to /dev/null...
379 */
380
381 if ((i = open("/dev/null", O_RDONLY)) != 0)
382 {
383 dup2(i, 0);
384 close(i);
385 }
386
387 if ((i = open("/dev/null", O_WRONLY)) != 1)
388 {
389 dup2(i, 1);
390 close(i);
391 }
392
393 if ((i = open("/dev/null", O_WRONLY)) != 2)
394 {
395 dup2(i, 2);
396 close(i);
397 }
398 }
399
400 /*
401 * Run in the background as needed...
402 */
403
404 if (!fg)
405 {
406 /*
407 * Setup signal handlers for the parent...
408 */
409
410 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
411 sigset(SIGUSR1, parent_handler);
412 sigset(SIGCHLD, parent_handler);
413
414 sigset(SIGHUP, SIG_IGN);
415 #elif defined(HAVE_SIGACTION)
416 memset(&action, 0, sizeof(action));
417 sigemptyset(&action.sa_mask);
418 sigaddset(&action.sa_mask, SIGUSR1);
419 action.sa_handler = parent_handler;
420 sigaction(SIGUSR1, &action, NULL);
421 sigaction(SIGCHLD, &action, NULL);
422
423 sigemptyset(&action.sa_mask);
424 action.sa_handler = SIG_IGN;
425 sigaction(SIGHUP, &action, NULL);
426 #else
427 signal(SIGUSR1, parent_handler);
428 signal(SIGCLD, parent_handler);
429
430 signal(SIGHUP, SIG_IGN);
431 #endif /* HAVE_SIGSET */
432
433 if (fork() > 0)
434 {
435 /*
436 * OK, wait for the child to startup and send us SIGUSR1 or to crash
437 * and the OS send us SIGCHLD... We also need to ignore SIGHUP which
438 * might be sent by the init script to restart the scheduler...
439 */
440
441 for (; parent_signal == 0;)
442 sleep(1);
443
444 if (parent_signal == SIGUSR1)
445 return (0);
446
447 if (wait(&i) < 0)
448 {
449 perror("cupsd");
450 return (1);
451 }
452 else if (WIFEXITED(i))
453 {
454 fprintf(stderr, "cupsd: Child exited with status %d\n",
455 WEXITSTATUS(i));
456 return (2);
457 }
458 else
459 {
460 fprintf(stderr, "cupsd: Child exited on signal %d\n", WTERMSIG(i));
461 return (3);
462 }
463 }
464
465 #if defined(__OpenBSD__) && OpenBSD < 201211
466 /*
467 * Call _thread_sys_closefrom() so the child process doesn't reset the
468 * parent's file descriptors to be blocking. This is a workaround for a
469 * limitation of userland libpthread on older versions of OpenBSD.
470 */
471
472 _thread_sys_closefrom(0);
473 #endif /* __OpenBSD__ && OpenBSD < 201211 */
474
475 /*
476 * Since many system libraries create fork-unsafe data on execution of a
477 * program, we need to re-execute the background cupsd with the "-C" and "-s"
478 * options to avoid problems. Unfortunately, we also have to assume that
479 * argv[0] contains the name of the cupsd executable - there is no portable
480 * way to get the real pathname...
481 */
482
483 execlp(argv[0], argv[0], "-C", ConfigurationFile, "-s", CupsFilesFile, (char *)0);
484 exit(errno);
485 }
486
487 /*
488 * Set the timezone info...
489 */
490
491 tzset();
492
493 #ifdef LC_TIME
494 setlocale(LC_TIME, "");
495 #endif /* LC_TIME */
496
497 #ifdef HAVE_DBUS_THREADS_INIT
498 /*
499 * Enable threading support for D-BUS...
500 */
501
502 dbus_threads_init_default();
503 #endif /* HAVE_DBUS_THREADS_INIT */
504
505 /*
506 * Set the maximum number of files...
507 */
508
509 getrlimit(RLIMIT_NOFILE, &limit);
510
511 #if !defined(HAVE_POLL) && !defined(HAVE_EPOLL) && !defined(HAVE_KQUEUE)
512 if (limit.rlim_max > FD_SETSIZE)
513 MaxFDs = FD_SETSIZE;
514 else
515 #endif /* !HAVE_POLL && !HAVE_EPOLL && !HAVE_KQUEUE */
516 #ifdef RLIM_INFINITY
517 if (limit.rlim_max == RLIM_INFINITY)
518 MaxFDs = 16384;
519 else
520 #endif /* RLIM_INFINITY */
521 MaxFDs = limit.rlim_max;
522
523 limit.rlim_cur = (rlim_t)MaxFDs;
524
525 setrlimit(RLIMIT_NOFILE, &limit);
526
527 cupsdStartSelect();
528
529 /*
530 * Read configuration...
531 */
532
533 if (!cupsdReadConfiguration())
534 return (1);
535 else if (TestConfigFile)
536 {
537 printf("\"%s\" is OK.\n", CupsFilesFile);
538 printf("\"%s\" is OK.\n", ConfigurationFile);
539 return (0);
540 }
541
542 /*
543 * Clean out old temp files and printer cache data.
544 */
545
546 if (!strncmp(TempDir, RequestRoot, strlen(RequestRoot)))
547 cupsdCleanFiles(TempDir, NULL);
548
549 cupsdCleanFiles(CacheDir, "*.ipp");
550
551 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
552 if (OnDemand)
553 {
554 /*
555 * If we were started on demand by launchd or systemd get the listen sockets
556 * file descriptors...
557 */
558
559 service_checkin();
560 service_checkout();
561 }
562 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
563
564 /*
565 * Startup the server...
566 */
567
568 httpInitialize();
569
570 cupsdStartServer();
571
572 /*
573 * Catch hangup and child signals and ignore broken pipes...
574 */
575
576 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
577 sigset(SIGCHLD, sigchld_handler);
578 sigset(SIGHUP, sighup_handler);
579 sigset(SIGPIPE, SIG_IGN);
580 sigset(SIGTERM, sigterm_handler);
581 #elif defined(HAVE_SIGACTION)
582 memset(&action, 0, sizeof(action));
583
584 sigemptyset(&action.sa_mask);
585 sigaddset(&action.sa_mask, SIGTERM);
586 sigaddset(&action.sa_mask, SIGCHLD);
587 action.sa_handler = sigchld_handler;
588 sigaction(SIGCHLD, &action, NULL);
589
590 sigemptyset(&action.sa_mask);
591 sigaddset(&action.sa_mask, SIGHUP);
592 action.sa_handler = sighup_handler;
593 sigaction(SIGHUP, &action, NULL);
594
595 sigemptyset(&action.sa_mask);
596 action.sa_handler = SIG_IGN;
597 sigaction(SIGPIPE, &action, NULL);
598
599 sigemptyset(&action.sa_mask);
600 sigaddset(&action.sa_mask, SIGTERM);
601 sigaddset(&action.sa_mask, SIGCHLD);
602 action.sa_handler = sigterm_handler;
603 sigaction(SIGTERM, &action, NULL);
604 #else
605 signal(SIGCLD, sigchld_handler); /* No, SIGCLD isn't a typo... */
606 signal(SIGHUP, sighup_handler);
607 signal(SIGPIPE, SIG_IGN);
608 signal(SIGTERM, sigterm_handler);
609 #endif /* HAVE_SIGSET */
610
611 /*
612 * Initialize authentication certificates...
613 */
614
615 cupsdInitCerts();
616
617 /*
618 * If we are running in the background, signal the parent process that
619 * we are up and running...
620 */
621
622 if (!fg || run_as_child)
623 {
624 /*
625 * Send a signal to the parent process, but only if the parent is
626 * not PID 1 (init). This avoids accidentally shutting down the
627 * system on OpenBSD if you CTRL-C the server before it is up...
628 */
629
630 i = getppid(); /* Save parent PID to avoid race condition */
631
632 if (i != 1)
633 kill(i, SIGUSR1);
634 }
635
636 #ifdef __APPLE__
637 /*
638 * Start power management framework...
639 */
640
641 if (use_sysman)
642 cupsdStartSystemMonitor();
643 #endif /* __APPLE__ */
644
645 /*
646 * Send server-started event...
647 */
648
649 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
650 if (OnDemand)
651 cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started on demand.");
652 else
653 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
654 if (fg)
655 cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started in foreground.");
656 else
657 cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started in background.");
658
659 /*
660 * Start any pending print jobs...
661 */
662
663 cupsdCheckJobs();
664
665 /*
666 * Loop forever...
667 */
668
669 current_time = time(NULL);
670 event_time = current_time;
671 expire_time = current_time;
672 fds = 1;
673 report_time = 0;
674 senddoc_time = current_time;
675
676 while (!stop_scheduler)
677 {
678 /*
679 * Check if there are dead children to handle...
680 */
681
682 if (dead_children)
683 process_children();
684
685 /*
686 * Check if we need to load the server configuration file...
687 */
688
689 if (NeedReload)
690 {
691 /*
692 * Close any idle clients...
693 */
694
695 if (cupsArrayCount(Clients) > 0)
696 {
697 for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
698 con;
699 con = (cupsd_client_t *)cupsArrayNext(Clients))
700 if (httpGetState(con->http) == HTTP_WAITING)
701 cupsdCloseClient(con);
702 else
703 con->http->keep_alive = HTTP_KEEPALIVE_OFF;
704
705 cupsdPauseListening();
706 }
707
708 /*
709 * Restart if all clients are closed and all jobs finished, or
710 * if the reload timeout has elapsed...
711 */
712
713 if ((cupsArrayCount(Clients) == 0 &&
714 (cupsArrayCount(PrintingJobs) == 0 || NeedReload != RELOAD_ALL)) ||
715 (time(NULL) - ReloadTime) >= ReloadTimeout)
716 {
717 /*
718 * Shutdown the server...
719 */
720
721 DoingShutdown = 1;
722
723 cupsdStopServer();
724
725 /*
726 * Read configuration...
727 */
728
729 if (!cupsdReadConfiguration())
730 {
731 syslog(LOG_LPR, "Unable to read configuration file \'%s\' - exiting!",
732 ConfigurationFile);
733 break;
734 }
735
736 /*
737 * Startup the server...
738 */
739
740 DoingShutdown = 0;
741
742 cupsdStartServer();
743
744 /*
745 * Send a server-restarted event...
746 */
747
748 cupsdAddEvent(CUPSD_EVENT_SERVER_RESTARTED, NULL, NULL,
749 "Scheduler restarted.");
750 }
751 }
752
753 /*
754 * Check for available input or ready output. If cupsdDoSelect()
755 * returns 0 or -1, something bad happened and we should exit
756 * immediately.
757 *
758 * Note that we at least have one listening socket open at all
759 * times.
760 */
761
762 if ((timeout = select_timeout(fds)) > 1 && LastEvent)
763 timeout = 1;
764
765 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
766 /*
767 * If no other work is scheduled and we're being controlled by
768 * launchd then timeout after 'LaunchdTimeout' seconds of
769 * inactivity...
770 */
771
772 if (timeout == 86400 && OnDemand && IdleExitTimeout &&
773 !cupsArrayCount(ActiveJobs) &&
774 # ifdef HAVE_SYSTEMD
775 !WebInterface &&
776 # endif /* HAVE_SYSTEMD */
777 (!Browsing || !BrowseLocalProtocols || !cupsArrayCount(Printers)))
778 {
779 timeout = IdleExitTimeout;
780 service_idle_exit = 1;
781 }
782 else
783 service_idle_exit = 0;
784 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
785
786 if ((fds = cupsdDoSelect(timeout)) < 0)
787 {
788 /*
789 * Got an error from select!
790 */
791
792 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
793 cupsd_printer_t *p; /* Current printer */
794 #endif /* HAVE_DNSSD || HAVE_AVAHI */
795
796
797 if (errno == EINTR) /* Just interrupted by a signal */
798 continue;
799
800 /*
801 * Log all sorts of debug info to help track down the problem.
802 */
803
804 cupsdLogMessage(CUPSD_LOG_EMERG, "cupsdDoSelect() failed - %s!",
805 strerror(errno));
806
807 for (i = 0, con = (cupsd_client_t *)cupsArrayFirst(Clients);
808 con;
809 i ++, con = (cupsd_client_t *)cupsArrayNext(Clients))
810 cupsdLogMessage(CUPSD_LOG_EMERG,
811 "Clients[%d] = %d, file = %d, state = %d",
812 i, con->number, con->file, httpGetState(con->http));
813
814 for (i = 0, lis = (cupsd_listener_t *)cupsArrayFirst(Listeners);
815 lis;
816 i ++, lis = (cupsd_listener_t *)cupsArrayNext(Listeners))
817 cupsdLogMessage(CUPSD_LOG_EMERG, "Listeners[%d] = %d", i, lis->fd);
818
819 cupsdLogMessage(CUPSD_LOG_EMERG, "CGIPipes[0] = %d", CGIPipes[0]);
820
821 #ifdef __APPLE__
822 cupsdLogMessage(CUPSD_LOG_EMERG, "SysEventPipes[0] = %d",
823 SysEventPipes[0]);
824 #endif /* __APPLE__ */
825
826 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
827 job;
828 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
829 cupsdLogMessage(CUPSD_LOG_EMERG, "Jobs[%d] = %d < [%d %d] > [%d %d]",
830 job->id,
831 job->status_buffer ? job->status_buffer->fd : -1,
832 job->print_pipes[0], job->print_pipes[1],
833 job->back_pipes[0], job->back_pipes[1]);
834
835 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
836 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
837 p;
838 p = (cupsd_printer_t *)cupsArrayNext(Printers))
839 cupsdLogMessage(CUPSD_LOG_EMERG, "printer[%s] reg_name=\"%s\"", p->name,
840 p->reg_name ? p->reg_name : "(null)");
841 #endif /* HAVE_DNSSD || HAVE_AVAHI */
842
843 break;
844 }
845
846 current_time = time(NULL);
847
848 /*
849 * Write dirty config/state files...
850 */
851
852 if (DirtyCleanTime && current_time >= DirtyCleanTime)
853 cupsdCleanDirty();
854
855 #ifdef __APPLE__
856 /*
857 * If we are going to sleep and still have pending jobs, stop them after
858 * a period of time...
859 */
860
861 if (SleepJobs > 0 && current_time >= SleepJobs &&
862 cupsArrayCount(PrintingJobs) > 0)
863 {
864 SleepJobs = 0;
865 cupsdStopAllJobs(CUPSD_JOB_DEFAULT, 5);
866 }
867 #endif /* __APPLE__ */
868
869 #ifndef __APPLE__
870 /*
871 * Update the network interfaces once a minute...
872 */
873
874 if ((current_time - netif_time) >= 60)
875 {
876 netif_time = current_time;
877 NetIFUpdate = 1;
878 }
879 #endif /* !__APPLE__ */
880
881 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
882 /*
883 * If no other work was scheduled and we're being controlled by launchd
884 * then timeout after 'LaunchdTimeout' seconds of inactivity...
885 */
886
887 if (!fds && service_idle_exit)
888 {
889 cupsdLogMessage(CUPSD_LOG_INFO,
890 "Printer sharing is off and there are no jobs pending, "
891 "will restart on demand.");
892 stop_scheduler = 1;
893 break;
894 }
895 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
896
897 /*
898 * Resume listening for new connections as needed...
899 */
900
901 if (ListeningPaused && ListeningPaused <= current_time &&
902 cupsArrayCount(Clients) < MaxClients)
903 cupsdResumeListening();
904
905 /*
906 * Expire subscriptions and unload completed jobs as needed...
907 */
908
909 if (current_time > expire_time)
910 {
911 if (cupsArrayCount(Subscriptions) > 0)
912 cupsdExpireSubscriptions(NULL, NULL);
913
914 cupsdUnloadCompletedJobs();
915
916 expire_time = current_time;
917 }
918
919 #ifndef HAVE_AUTHORIZATION_H
920 /*
921 * Update the root certificate once every 5 minutes if we have client
922 * connections...
923 */
924
925 if ((current_time - RootCertTime) >= RootCertDuration && RootCertDuration &&
926 !RunUser && cupsArrayCount(Clients))
927 {
928 /*
929 * Update the root certificate...
930 */
931
932 cupsdDeleteCert(0);
933 cupsdAddCert(0, "root", cupsdDefaultAuthType());
934 }
935 #endif /* !HAVE_AUTHORIZATION_H */
936
937 /*
938 * Check for new data on the client sockets...
939 */
940
941 for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
942 con;
943 con = (cupsd_client_t *)cupsArrayNext(Clients))
944 {
945 /*
946 * Process pending data in the input buffer...
947 */
948
949 if (httpGetReady(con->http))
950 {
951 cupsdReadClient(con);
952 continue;
953 }
954
955 /*
956 * Check the activity and close old clients...
957 */
958
959 activity = current_time - Timeout;
960 if (httpGetActivity(con->http) < activity && !con->pipe_pid)
961 {
962 cupsdLogMessage(CUPSD_LOG_DEBUG, "Closing client %d after %d seconds of inactivity.", con->number, Timeout);
963
964 cupsdCloseClient(con);
965 continue;
966 }
967 }
968
969 /*
970 * Update any pending multi-file documents...
971 */
972
973 if ((current_time - senddoc_time) >= 10)
974 {
975 cupsdCheckJobs();
976 senddoc_time = current_time;
977 }
978
979 /*
980 * Clean job history...
981 */
982
983 if (JobHistoryUpdate && current_time >= JobHistoryUpdate)
984 cupsdCleanJobs();
985
986 /*
987 * Log statistics at most once a minute when in debug mode...
988 */
989
990 if ((current_time - report_time) >= 60 && LogLevel >= CUPSD_LOG_DEBUG)
991 {
992 size_t string_count, /* String count */
993 alloc_bytes, /* Allocated string bytes */
994 total_bytes; /* Total string bytes */
995 #ifdef HAVE_MALLINFO
996 struct mallinfo mem; /* Malloc information */
997
998
999 mem = mallinfo();
1000 cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-arena=%lu", mem.arena);
1001 cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-used=%lu",
1002 mem.usmblks + mem.uordblks);
1003 cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-free=%lu",
1004 mem.fsmblks + mem.fordblks);
1005 #endif /* HAVE_MALLINFO */
1006
1007 cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: clients=%d",
1008 cupsArrayCount(Clients));
1009 cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: jobs=%d",
1010 cupsArrayCount(Jobs));
1011 cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: jobs-active=%d",
1012 cupsArrayCount(ActiveJobs));
1013 cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: printers=%d",
1014 cupsArrayCount(Printers));
1015
1016 string_count = _cupsStrStatistics(&alloc_bytes, &total_bytes);
1017 cupsdLogMessage(CUPSD_LOG_DEBUG,
1018 "Report: stringpool-string-count=" CUPS_LLFMT,
1019 CUPS_LLCAST string_count);
1020 cupsdLogMessage(CUPSD_LOG_DEBUG,
1021 "Report: stringpool-alloc-bytes=" CUPS_LLFMT,
1022 CUPS_LLCAST alloc_bytes);
1023 cupsdLogMessage(CUPSD_LOG_DEBUG,
1024 "Report: stringpool-total-bytes=" CUPS_LLFMT,
1025 CUPS_LLCAST total_bytes);
1026
1027 report_time = current_time;
1028 }
1029
1030 /*
1031 * Handle OS-specific event notification for any events that have
1032 * accumulated. Don't send these more than once a second...
1033 */
1034
1035 if (LastEvent && (current_time - event_time) >= 1)
1036 {
1037 #ifdef HAVE_NOTIFY_POST
1038 if (LastEvent & (CUPSD_EVENT_PRINTER_ADDED |
1039 CUPSD_EVENT_PRINTER_DELETED |
1040 CUPSD_EVENT_PRINTER_MODIFIED))
1041 {
1042 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1043 "notify_post(\"com.apple.printerListChange\")");
1044 notify_post("com.apple.printerListChange");
1045 }
1046
1047 if (LastEvent & CUPSD_EVENT_PRINTER_STATE_CHANGED)
1048 {
1049 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1050 "notify_post(\"com.apple.printerHistoryChange\")");
1051 notify_post("com.apple.printerHistoryChange");
1052 }
1053
1054 if (LastEvent & (CUPSD_EVENT_JOB_STATE_CHANGED |
1055 CUPSD_EVENT_JOB_CONFIG_CHANGED |
1056 CUPSD_EVENT_JOB_PROGRESS))
1057 {
1058 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1059 "notify_post(\"com.apple.jobChange\")");
1060 notify_post("com.apple.jobChange");
1061 }
1062 #endif /* HAVE_NOTIFY_POST */
1063
1064 /*
1065 * Reset the accumulated events...
1066 */
1067
1068 LastEvent = CUPSD_EVENT_NONE;
1069 event_time = current_time;
1070 }
1071 }
1072
1073 /*
1074 * Log a message based on what happened...
1075 */
1076
1077 if (stop_scheduler)
1078 {
1079 cupsdLogMessage(CUPSD_LOG_INFO, "Scheduler shutting down normally.");
1080 cupsdAddEvent(CUPSD_EVENT_SERVER_STOPPED, NULL, NULL,
1081 "Scheduler shutting down normally.");
1082 }
1083 else
1084 {
1085 cupsdLogMessage(CUPSD_LOG_ERROR,
1086 "Scheduler shutting down due to program error.");
1087 cupsdAddEvent(CUPSD_EVENT_SERVER_STOPPED, NULL, NULL,
1088 "Scheduler shutting down due to program error.");
1089 }
1090
1091 /*
1092 * Close all network clients...
1093 */
1094
1095 DoingShutdown = 1;
1096
1097 cupsdStopServer();
1098
1099 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
1100 /*
1101 * Update the keep-alive file as needed...
1102 */
1103
1104 if (OnDemand)
1105 service_checkout();
1106 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
1107
1108 /*
1109 * Stop all jobs...
1110 */
1111
1112 cupsdFreeAllJobs();
1113
1114 #ifdef __APPLE__
1115 /*
1116 * Stop monitoring system event monitoring...
1117 */
1118
1119 if (use_sysman)
1120 cupsdStopSystemMonitor();
1121 #endif /* __APPLE__ */
1122
1123 cupsdStopSelect();
1124
1125 return (!stop_scheduler);
1126 }
1127
1128
1129 /*
1130 * 'cupsdAddString()' - Copy and add a string to an array.
1131 */
1132
1133 int /* O - 1 on success, 0 on failure */
1134 cupsdAddString(cups_array_t **a, /* IO - String array */
1135 const char *s) /* I - String to copy and add */
1136 {
1137 if (!*a)
1138 *a = cupsArrayNew3((cups_array_func_t)strcmp, NULL,
1139 (cups_ahash_func_t)NULL, 0,
1140 (cups_acopy_func_t)_cupsStrAlloc,
1141 (cups_afree_func_t)_cupsStrFree);
1142
1143 return (cupsArrayAdd(*a, (char *)s));
1144 }
1145
1146
1147 /*
1148 * 'cupsdCheckProcess()' - Tell the main loop to check for dead children.
1149 */
1150
1151 void
1152 cupsdCheckProcess(void)
1153 {
1154 /*
1155 * Flag that we have dead children...
1156 */
1157
1158 dead_children = 1;
1159 }
1160
1161
1162 /*
1163 * 'cupsdClearString()' - Clear a string.
1164 */
1165
1166 void
1167 cupsdClearString(char **s) /* O - String value */
1168 {
1169 if (s && *s)
1170 {
1171 _cupsStrFree(*s);
1172 *s = NULL;
1173 }
1174 }
1175
1176
1177 /*
1178 * 'cupsdFreeStrings()' - Free an array of strings.
1179 */
1180
1181 void
1182 cupsdFreeStrings(cups_array_t **a) /* IO - String array */
1183 {
1184 if (*a)
1185 {
1186 cupsArrayDelete(*a);
1187 *a = NULL;
1188 }
1189 }
1190
1191
1192 /*
1193 * 'cupsdHoldSignals()' - Hold child and termination signals.
1194 */
1195
1196 void
1197 cupsdHoldSignals(void)
1198 {
1199 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
1200 sigset_t newmask; /* New POSIX signal mask */
1201 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
1202
1203
1204 holdcount ++;
1205 if (holdcount > 1)
1206 return;
1207
1208 #ifdef HAVE_SIGSET
1209 sighold(SIGTERM);
1210 sighold(SIGCHLD);
1211 #elif defined(HAVE_SIGACTION)
1212 sigemptyset(&newmask);
1213 sigaddset(&newmask, SIGTERM);
1214 sigaddset(&newmask, SIGCHLD);
1215 sigprocmask(SIG_BLOCK, &newmask, &holdmask);
1216 #endif /* HAVE_SIGSET */
1217 }
1218
1219
1220 /*
1221 * 'cupsdReleaseSignals()' - Release signals for delivery.
1222 */
1223
1224 void
1225 cupsdReleaseSignals(void)
1226 {
1227 holdcount --;
1228 if (holdcount > 0)
1229 return;
1230
1231 #ifdef HAVE_SIGSET
1232 sigrelse(SIGTERM);
1233 sigrelse(SIGCHLD);
1234 #elif defined(HAVE_SIGACTION)
1235 sigprocmask(SIG_SETMASK, &holdmask, NULL);
1236 #endif /* HAVE_SIGSET */
1237 }
1238
1239
1240 /*
1241 * 'cupsdSetString()' - Set a string value.
1242 */
1243
1244 void
1245 cupsdSetString(char **s, /* O - New string */
1246 const char *v) /* I - String value */
1247 {
1248 if (!s || *s == v)
1249 return;
1250
1251 if (*s)
1252 _cupsStrFree(*s);
1253
1254 if (v)
1255 *s = _cupsStrAlloc(v);
1256 else
1257 *s = NULL;
1258 }
1259
1260
1261 /*
1262 * 'cupsdSetStringf()' - Set a formatted string value.
1263 */
1264
1265 void
1266 cupsdSetStringf(char **s, /* O - New string */
1267 const char *f, /* I - Printf-style format string */
1268 ...) /* I - Additional args as needed */
1269 {
1270 char v[65536 + 64]; /* Formatting string value */
1271 va_list ap; /* Argument pointer */
1272 char *olds; /* Old string */
1273
1274
1275 if (!s)
1276 return;
1277
1278 olds = *s;
1279
1280 if (f)
1281 {
1282 va_start(ap, f);
1283 vsnprintf(v, sizeof(v), f, ap);
1284 va_end(ap);
1285
1286 *s = _cupsStrAlloc(v);
1287 }
1288 else
1289 *s = NULL;
1290
1291 if (olds)
1292 _cupsStrFree(olds);
1293 }
1294
1295
1296 /*
1297 * 'parent_handler()' - Catch USR1/CHLD signals...
1298 */
1299
1300 static void
1301 parent_handler(int sig) /* I - Signal */
1302 {
1303 /*
1304 * Store the signal we got from the OS and return...
1305 */
1306
1307 parent_signal = sig;
1308 }
1309
1310
1311 /*
1312 * 'process_children()' - Process all dead children...
1313 */
1314
1315 static void
1316 process_children(void)
1317 {
1318 int status; /* Exit status of child */
1319 int pid, /* Process ID of child */
1320 job_id; /* Job ID of child */
1321 cupsd_job_t *job; /* Current job */
1322 int i; /* Looping var */
1323 char name[1024]; /* Process name */
1324 const char *type; /* Type of program */
1325
1326
1327 cupsdLogMessage(CUPSD_LOG_DEBUG2, "process_children()");
1328
1329 /*
1330 * Reset the dead_children flag...
1331 */
1332
1333 dead_children = 0;
1334
1335 /*
1336 * Collect the exit status of some children...
1337 */
1338
1339 #ifdef HAVE_WAITPID
1340 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
1341 #elif defined(HAVE_WAIT3)
1342 while ((pid = wait3(&status, WNOHANG, NULL)) > 0)
1343 #else
1344 if ((pid = wait(&status)) > 0)
1345 #endif /* HAVE_WAITPID */
1346 {
1347 /*
1348 * Collect the name of the process that finished...
1349 */
1350
1351 cupsdFinishProcess(pid, name, sizeof(name), &job_id);
1352
1353 /*
1354 * Delete certificates for CGI processes...
1355 */
1356
1357 if (pid)
1358 cupsdDeleteCert(pid);
1359
1360 /*
1361 * Handle completed job filters...
1362 */
1363
1364 if (job_id > 0)
1365 job = cupsdFindJob(job_id);
1366 else
1367 job = NULL;
1368
1369 if (job)
1370 {
1371 for (i = 0; job->filters[i]; i ++)
1372 if (job->filters[i] == pid)
1373 break;
1374
1375 if (job->filters[i] || job->backend == pid)
1376 {
1377 /*
1378 * OK, this process has gone away; what's left?
1379 */
1380
1381 if (job->filters[i])
1382 {
1383 job->filters[i] = -pid;
1384 type = "Filter";
1385 }
1386 else
1387 {
1388 job->backend = -pid;
1389 type = "Backend";
1390 }
1391
1392 if (status && status != SIGTERM && status != SIGKILL &&
1393 status != SIGPIPE)
1394 {
1395 /*
1396 * An error occurred; save the exit status so we know to stop
1397 * the printer or cancel the job when all of the filters finish...
1398 *
1399 * A negative status indicates that the backend failed and the
1400 * printer needs to be stopped.
1401 *
1402 * In order to preserve the most serious status, we always log
1403 * when a process dies due to a signal (e.g. SIGABRT, SIGSEGV,
1404 * and SIGBUS) and prefer to log the backend exit status over a
1405 * filter's.
1406 */
1407
1408 int old_status = abs(job->status);
1409
1410 if (WIFSIGNALED(status) || /* This process crashed, or */
1411 !job->status || /* No process had a status, or */
1412 (!job->filters[i] && WIFEXITED(old_status)))
1413 { /* Backend and filter didn't crash */
1414 if (job->filters[i])
1415 job->status = status; /* Filter failed */
1416 else
1417 job->status = -status; /* Backend failed */
1418 }
1419
1420 if (job->state_value == IPP_JOB_PROCESSING &&
1421 job->status_level > CUPSD_LOG_ERROR &&
1422 (job->filters[i] || !WIFEXITED(status)))
1423 {
1424 char message[1024]; /* New printer-state-message */
1425
1426
1427 job->status_level = CUPSD_LOG_ERROR;
1428
1429 snprintf(message, sizeof(message), "%s failed", type);
1430
1431 if (job->printer)
1432 {
1433 strlcpy(job->printer->state_message, message,
1434 sizeof(job->printer->state_message));
1435 }
1436
1437 if (!job->attrs)
1438 cupsdLoadJob(job);
1439
1440 if (!job->printer_message && job->attrs)
1441 {
1442 if ((job->printer_message =
1443 ippFindAttribute(job->attrs, "job-printer-state-message",
1444 IPP_TAG_TEXT)) == NULL)
1445 job->printer_message = ippAddString(job->attrs, IPP_TAG_JOB,
1446 IPP_TAG_TEXT,
1447 "job-printer-state-message",
1448 NULL, NULL);
1449 }
1450
1451 if (job->printer_message)
1452 cupsdSetString(&(job->printer_message->values[0].string.text),
1453 message);
1454 }
1455 }
1456
1457 /*
1458 * If this is not the last file in a job, see if all of the
1459 * filters are done, and if so move to the next file.
1460 */
1461
1462 if (job->current_file < job->num_files && job->printer)
1463 {
1464 for (i = 0; job->filters[i] < 0; i ++);
1465
1466 if (!job->filters[i] &&
1467 (!job->printer->pc || !job->printer->pc->single_file ||
1468 job->backend <= 0))
1469 {
1470 /*
1471 * Process the next file...
1472 */
1473
1474 cupsdContinueJob(job);
1475 }
1476 }
1477 else if (job->state_value >= IPP_JOB_CANCELED)
1478 {
1479 /*
1480 * Remove the job from the active list if there are no processes still
1481 * running for it...
1482 */
1483
1484 for (i = 0; job->filters[i] < 0; i++);
1485
1486 if (!job->filters[i] && job->backend <= 0)
1487 cupsArrayRemove(ActiveJobs, job);
1488 }
1489 }
1490 }
1491
1492 /*
1493 * Show the exit status as needed, ignoring SIGTERM and SIGKILL errors
1494 * since they come when we kill/end a process...
1495 */
1496
1497 if (status == SIGTERM || status == SIGKILL)
1498 {
1499 cupsdLogJob(job, CUPSD_LOG_DEBUG,
1500 "PID %d (%s) was terminated normally with signal %d.", pid,
1501 name, status);
1502 }
1503 else if (status == SIGPIPE)
1504 {
1505 cupsdLogJob(job, CUPSD_LOG_DEBUG,
1506 "PID %d (%s) did not catch or ignore signal %d.", pid, name,
1507 status);
1508 }
1509 else if (status)
1510 {
1511 if (WIFEXITED(status))
1512 {
1513 int code = WEXITSTATUS(status); /* Exit code */
1514
1515 if (code > 100)
1516 cupsdLogJob(job, CUPSD_LOG_DEBUG,
1517 "PID %d (%s) stopped with status %d (%s)", pid, name,
1518 code, strerror(code - 100));
1519 else
1520 cupsdLogJob(job, CUPSD_LOG_DEBUG,
1521 "PID %d (%s) stopped with status %d.", pid, name, code);
1522 }
1523 else
1524 cupsdLogJob(job, CUPSD_LOG_DEBUG, "PID %d (%s) crashed on signal %d.",
1525 pid, name, WTERMSIG(status));
1526
1527 if (LogLevel < CUPSD_LOG_DEBUG)
1528 cupsdLogJob(job, CUPSD_LOG_INFO,
1529 "Hint: Try setting the LogLevel to \"debug\" to find out "
1530 "more.");
1531 }
1532 else
1533 cupsdLogJob(job, CUPSD_LOG_DEBUG, "PID %d (%s) exited with no errors.",
1534 pid, name);
1535 }
1536
1537 /*
1538 * If wait*() is interrupted by a signal, tell main() to call us again...
1539 */
1540
1541 if (pid < 0 && errno == EINTR)
1542 dead_children = 1;
1543 }
1544
1545
1546 /*
1547 * 'select_timeout()' - Calculate the select timeout value.
1548 *
1549 */
1550
1551 static long /* O - Number of seconds */
1552 select_timeout(int fds) /* I - Number of descriptors returned */
1553 {
1554 long timeout; /* Timeout for select */
1555 time_t now; /* Current time */
1556 cupsd_client_t *con; /* Client information */
1557 cupsd_job_t *job; /* Job information */
1558 cupsd_subscription_t *sub; /* Subscription information */
1559 const char *why; /* Debugging aid */
1560
1561
1562 cupsdLogMessage(CUPSD_LOG_DEBUG2, "select_timeout: JobHistoryUpdate=%ld",
1563 (long)JobHistoryUpdate);
1564
1565 /*
1566 * Check to see if any of the clients have pending data to be
1567 * processed; if so, the timeout should be 0...
1568 */
1569
1570 for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
1571 con;
1572 con = (cupsd_client_t *)cupsArrayNext(Clients))
1573 if (httpGetReady(con->http))
1574 return (0);
1575
1576 /*
1577 * If select has been active in the last second (fds > 0) or we have
1578 * many resources in use then don't bother trying to optimize the
1579 * timeout, just make it 1 second.
1580 */
1581
1582 if (fds > 0 || cupsArrayCount(Clients) > 50)
1583 return (1);
1584
1585 /*
1586 * Otherwise, check all of the possible events that we need to wake for...
1587 */
1588
1589 now = time(NULL);
1590 timeout = now + 86400; /* 86400 == 1 day */
1591 why = "do nothing";
1592
1593 #ifdef __APPLE__
1594 /*
1595 * When going to sleep, wake up to cancel jobs that don't complete in time.
1596 */
1597
1598 if (SleepJobs > 0 && SleepJobs < timeout)
1599 {
1600 timeout = SleepJobs;
1601 why = "cancel jobs before sleeping";
1602 }
1603 #endif /* __APPLE__ */
1604
1605 /*
1606 * Check whether we are accepting new connections...
1607 */
1608
1609 if (ListeningPaused > 0 && cupsArrayCount(Clients) < MaxClients &&
1610 ListeningPaused < timeout)
1611 {
1612 if (ListeningPaused <= now)
1613 timeout = now;
1614 else
1615 timeout = ListeningPaused;
1616
1617 why = "resume listening";
1618 }
1619
1620 /*
1621 * Check the activity and close old clients...
1622 */
1623
1624 for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
1625 con;
1626 con = (cupsd_client_t *)cupsArrayNext(Clients))
1627 if ((httpGetActivity(con->http) + Timeout) < timeout)
1628 {
1629 timeout = httpGetActivity(con->http) + Timeout;
1630 why = "timeout a client connection";
1631 }
1632
1633 /*
1634 * Write out changes to configuration and state files...
1635 */
1636
1637 if (DirtyCleanTime && timeout > DirtyCleanTime)
1638 {
1639 timeout = DirtyCleanTime;
1640 why = "write dirty config/state files";
1641 }
1642
1643 /*
1644 * Check for any job activity...
1645 */
1646
1647 if (JobHistoryUpdate && timeout > JobHistoryUpdate)
1648 {
1649 timeout = JobHistoryUpdate;
1650 why = "update job history";
1651 }
1652
1653 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
1654 job;
1655 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
1656 {
1657 if (job->cancel_time && job->cancel_time < timeout)
1658 {
1659 timeout = job->cancel_time;
1660 why = "cancel stuck jobs";
1661 }
1662
1663 if (job->kill_time && job->kill_time < timeout)
1664 {
1665 timeout = job->kill_time;
1666 why = "kill unresponsive jobs";
1667 }
1668
1669 if (job->state_value == IPP_JOB_HELD && job->hold_until < timeout)
1670 {
1671 timeout = job->hold_until;
1672 why = "release held jobs";
1673 }
1674
1675 if (job->state_value == IPP_JOB_PENDING && timeout > (now + 10))
1676 {
1677 timeout = now + 10;
1678 why = "start pending jobs";
1679 break;
1680 }
1681 }
1682
1683 #ifdef HAVE_MALLINFO
1684 /*
1685 * Log memory usage every minute...
1686 */
1687
1688 if (LogLevel >= CUPSD_LOG_DEBUG && (mallinfo_time + 60) < timeout)
1689 {
1690 timeout = mallinfo_time + 60;
1691 why = "display memory usage";
1692 }
1693 #endif /* HAVE_MALLINFO */
1694
1695 /*
1696 * Expire subscriptions as needed...
1697 */
1698
1699 for (sub = (cupsd_subscription_t *)cupsArrayFirst(Subscriptions);
1700 sub;
1701 sub = (cupsd_subscription_t *)cupsArrayNext(Subscriptions))
1702 if (!sub->job && sub->expire && sub->expire < timeout)
1703 {
1704 timeout = sub->expire;
1705 why = "expire subscription";
1706 }
1707
1708 /*
1709 * Adjust from absolute to relative time. We add 1 second to the timeout since
1710 * events occur after the timeout expires, and limit the timeout to 86400
1711 * seconds (1 day) to avoid select() timeout limits present on some operating
1712 * systems...
1713 */
1714
1715 timeout = timeout - now + 1;
1716
1717 if (timeout < 1)
1718 timeout = 1;
1719 else if (timeout > 86400)
1720 timeout = 86400;
1721
1722 /*
1723 * Log and return the timeout value...
1724 */
1725
1726 cupsdLogMessage(CUPSD_LOG_DEBUG2, "select_timeout(%d): %ld seconds to %s",
1727 fds, timeout, why);
1728
1729 return (timeout);
1730 }
1731
1732
1733 /*
1734 * 'sigchld_handler()' - Handle 'child' signals from old processes.
1735 */
1736
1737 static void
1738 sigchld_handler(int sig) /* I - Signal number */
1739 {
1740 (void)sig;
1741
1742 /*
1743 * Flag that we have dead children...
1744 */
1745
1746 dead_children = 1;
1747
1748 /*
1749 * Reset the signal handler as needed...
1750 */
1751
1752 #if !defined(HAVE_SIGSET) && !defined(HAVE_SIGACTION)
1753 signal(SIGCLD, sigchld_handler);
1754 #endif /* !HAVE_SIGSET && !HAVE_SIGACTION */
1755 }
1756
1757
1758 /*
1759 * 'sighup_handler()' - Handle 'hangup' signals to reconfigure the scheduler.
1760 */
1761
1762 static void
1763 sighup_handler(int sig) /* I - Signal number */
1764 {
1765 (void)sig;
1766
1767 NeedReload = RELOAD_ALL;
1768 ReloadTime = time(NULL);
1769
1770 #if !defined(HAVE_SIGSET) && !defined(HAVE_SIGACTION)
1771 signal(SIGHUP, sighup_handler);
1772 #endif /* !HAVE_SIGSET && !HAVE_SIGACTION */
1773 }
1774
1775
1776 /*
1777 * 'sigterm_handler()' - Handle 'terminate' signals that stop the scheduler.
1778 */
1779
1780 static void
1781 sigterm_handler(int sig) /* I - Signal number */
1782 {
1783 (void)sig; /* remove compiler warnings... */
1784
1785 /*
1786 * Flag that we should stop and return...
1787 */
1788
1789 stop_scheduler = 1;
1790 }
1791
1792
1793 #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD)
1794 /*
1795 * 'service_checkin()' - Check-in with launchd and collect the listening fds.
1796 */
1797
1798 static void
1799 service_checkin(void)
1800 {
1801 # ifdef HAVE_LAUNCH_ACTIVATE_SOCKET
1802 int error; /* Check-in error, if any */
1803 size_t i, /* Looping var */
1804 count; /* Number of listeners */
1805 int *ld_sockets; /* Listener sockets */
1806 cupsd_listener_t *lis; /* Listeners array */
1807 http_addr_t addr; /* Address variable */
1808 socklen_t addrlen; /* Length of address */
1809 char s[256]; /* String addresss */
1810
1811
1812 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: pid=%d", (int)getpid());
1813
1814 /*
1815 * Check-in with launchd...
1816 */
1817
1818 if ((error = launch_activate_socket("Listeners", &ld_sockets, &count)) != 0)
1819 {
1820 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Unable to get listener sockets: %s", strerror(error));
1821 exit(EXIT_FAILURE);
1822 return; /* anti-compiler-warning */
1823 }
1824
1825 /*
1826 * Try to match the launchd sockets to the cupsd listeners...
1827 */
1828
1829 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: %d listeners.", (int)count);
1830
1831 for (i = 0; i < count; i ++)
1832 {
1833 /*
1834 * Get the launchd socket address...
1835 */
1836
1837 addrlen = sizeof(addr);
1838
1839 if (getsockname(ld_sockets[i], (struct sockaddr *)&addr, &addrlen))
1840 {
1841 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Unable to get local address for listener #%d: %s", (int)i + 1, strerror(errno));
1842 continue;
1843 }
1844
1845 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Listener #%d at fd %d, \"%s\".", (int)i + 1, ld_sockets[i], httpAddrString(&addr, s, sizeof(s)));
1846
1847 for (lis = (cupsd_listener_t *)cupsArrayFirst(Listeners);
1848 lis;
1849 lis = (cupsd_listener_t *)cupsArrayNext(Listeners))
1850 if (httpAddrEqual(&lis->address, &addr))
1851 break;
1852
1853 /*
1854 * Add a new listener if there's no match...
1855 */
1856
1857 if (lis)
1858 {
1859 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Matched existing listener #%d to %s.", (int)i + 1, httpAddrString(&(lis->address), s, sizeof(s)));
1860 }
1861 else
1862 {
1863 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Adding new listener #%d for %s.", (int)i + 1, httpAddrString(&addr, s, sizeof(s)));
1864
1865 if ((lis = calloc(1, sizeof(cupsd_listener_t))) == NULL)
1866 {
1867 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Unable to allocate listener: %s", strerror(errno));
1868 exit(EXIT_FAILURE);
1869 }
1870
1871 cupsArrayAdd(Listeners, lis);
1872
1873 memcpy(&lis->address, &addr, sizeof(lis->address));
1874 }
1875
1876 lis->fd = ld_sockets[i];
1877 lis->on_demand = 1;
1878
1879 # ifdef HAVE_SSL
1880 if (httpAddrPort(&(lis->address)) == 443)
1881 lis->encryption = HTTP_ENCRYPT_ALWAYS;
1882 # endif /* HAVE_SSL */
1883 }
1884
1885 free(ld_sockets);
1886
1887 # elif defined(HAVE_LAUNCHD)
1888 size_t i, /* Looping var */
1889 count; /* Number of listeners */
1890 launch_data_t ld_msg, /* Launch data message */
1891 ld_resp, /* Launch data response */
1892 ld_array, /* Launch data array */
1893 ld_sockets, /* Launch data sockets dictionary */
1894 tmp; /* Launch data */
1895 cupsd_listener_t *lis; /* Listeners array */
1896 http_addr_t addr; /* Address variable */
1897 socklen_t addrlen; /* Length of address */
1898 int fd; /* File descriptor */
1899 char s[256]; /* String addresss */
1900
1901
1902 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: pid=%d", (int)getpid());
1903
1904 /*
1905 * Check-in with launchd...
1906 */
1907
1908 ld_msg = launch_data_new_string(LAUNCH_KEY_CHECKIN);
1909 if ((ld_resp = launch_msg(ld_msg)) == NULL)
1910 {
1911 cupsdLogMessage(CUPSD_LOG_ERROR,
1912 "service_checkin: launch_msg(\"" LAUNCH_KEY_CHECKIN
1913 "\") IPC failure");
1914 exit(EXIT_FAILURE);
1915 return; /* anti-compiler-warning */
1916 }
1917
1918 if (launch_data_get_type(ld_resp) == LAUNCH_DATA_ERRNO)
1919 {
1920 errno = launch_data_get_errno(ld_resp);
1921 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Check-in failed: %s",
1922 strerror(errno));
1923 exit(EXIT_FAILURE);
1924 return; /* anti-compiler-warning */
1925 }
1926
1927 /*
1928 * Get the sockets dictionary...
1929 */
1930
1931 if ((ld_sockets = launch_data_dict_lookup(ld_resp, LAUNCH_JOBKEY_SOCKETS))
1932 == NULL)
1933 {
1934 cupsdLogMessage(CUPSD_LOG_ERROR,
1935 "service_checkin: No sockets found to answer requests on.");
1936 exit(EXIT_FAILURE);
1937 return; /* anti-compiler-warning */
1938 }
1939
1940 /*
1941 * Get the array of listener sockets...
1942 */
1943
1944 if ((ld_array = launch_data_dict_lookup(ld_sockets, "Listeners")) == NULL)
1945 {
1946 cupsdLogMessage(CUPSD_LOG_ERROR,
1947 "service_checkin: No sockets found to answer requests on.");
1948 exit(EXIT_FAILURE);
1949 return; /* anti-compiler-warning */
1950 }
1951
1952 /*
1953 * Add listening fd(s) to the Listener array...
1954 */
1955
1956 if (launch_data_get_type(ld_array) == LAUNCH_DATA_ARRAY)
1957 {
1958 count = launch_data_array_get_count(ld_array);
1959
1960 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: %d listeners.", (int)count);
1961
1962 for (i = 0; i < count; i ++)
1963 {
1964 /*
1965 * Get the launchd file descriptor and address...
1966 */
1967
1968 if ((tmp = launch_data_array_get_index(ld_array, i)) != NULL)
1969 {
1970 fd = launch_data_get_fd(tmp);
1971 addrlen = sizeof(addr);
1972
1973 if (getsockname(fd, (struct sockaddr *)&addr, &addrlen))
1974 {
1975 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Unable to get local address for listener #%d: %s", (int)i + 1, strerror(errno));
1976 continue;
1977 }
1978
1979 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Listener #%d at fd %d, \"%s\".", (int)i + 1, fd, httpAddrString(&addr, s, sizeof(s)));
1980
1981 /*
1982 * Try to match the launchd socket address to one of the listeners...
1983 */
1984
1985 for (lis = (cupsd_listener_t *)cupsArrayFirst(Listeners);
1986 lis;
1987 lis = (cupsd_listener_t *)cupsArrayNext(Listeners))
1988 if (httpAddrEqual(&lis->address, &addr))
1989 break;
1990
1991 /*
1992 * Add a new listener If there's no match...
1993 */
1994
1995 if (lis)
1996 {
1997 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Matched existing listener #%d to %s.", (int)i + 1, httpAddrString(&(lis->address), s, sizeof(s)));
1998 }
1999 else
2000 {
2001 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Adding new listener #%d for %s.", (int)i + 1, httpAddrString(&addr, s, sizeof(s)));
2002
2003 if ((lis = calloc(1, sizeof(cupsd_listener_t))) == NULL)
2004 {
2005 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Unable to allocate listener: %s.", strerror(errno));
2006 exit(EXIT_FAILURE);
2007 }
2008
2009 cupsArrayAdd(Listeners, lis);
2010
2011 memcpy(&lis->address, &addr, sizeof(lis->address));
2012 }
2013
2014 lis->fd = fd;
2015 lis->on_demand = 1;
2016
2017 # ifdef HAVE_SSL
2018 if (httpAddrPort(&(lis->address)) == 443)
2019 lis->encryption = HTTP_ENCRYPT_ALWAYS;
2020 # endif /* HAVE_SSL */
2021 }
2022 }
2023 }
2024
2025 launch_data_free(ld_msg);
2026 launch_data_free(ld_resp);
2027
2028 # else /* HAVE_SYSTEMD */
2029 int i, /* Looping var */
2030 count; /* Number of listeners */
2031 cupsd_listener_t *lis; /* Listeners array */
2032 http_addr_t addr; /* Address variable */
2033 socklen_t addrlen; /* Length of address */
2034 char s[256]; /* String addresss */
2035
2036
2037 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: pid=%d", (int)getpid());
2038
2039 /*
2040 * Check-in with systemd...
2041 */
2042
2043 if ((count = sd_listen_fds(0)) < 0)
2044 {
2045 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Unable to get listener sockets: %s", strerror(-count));
2046 exit(EXIT_FAILURE);
2047 return; /* anti-compiler-warning */
2048 }
2049
2050 /*
2051 * Try to match the systemd sockets to the cupsd listeners...
2052 */
2053
2054 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: %d listeners.", count);
2055
2056 for (i = 0; i < count; i ++)
2057 {
2058 /*
2059 * Get the launchd socket address...
2060 */
2061
2062 addrlen = sizeof(addr);
2063
2064 if (getsockname(SD_LISTEN_FDS_START + i, (struct sockaddr *)&addr, &addrlen))
2065 {
2066 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Unable to get local address for listener #%d: %s", (int)i + 1, strerror(errno));
2067 continue;
2068 }
2069
2070 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Listener #%d at fd %d, \"%s\".", (int)i + 1, SD_LISTEN_FDS_START + i, httpAddrString(&addr, s, sizeof(s)));
2071
2072 for (lis = (cupsd_listener_t *)cupsArrayFirst(Listeners);
2073 lis;
2074 lis = (cupsd_listener_t *)cupsArrayNext(Listeners))
2075 if (httpAddrEqual(&lis->address, &addr))
2076 break;
2077
2078 /*
2079 * Add a new listener if there's no match...
2080 */
2081
2082 if (lis)
2083 {
2084 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Matched existing listener #%d to %s.", (int)i + 1, httpAddrString(&(lis->address), s, sizeof(s)));
2085 }
2086 else
2087 {
2088 cupsdLogMessage(CUPSD_LOG_DEBUG, "service_checkin: Adding new listener #%d for %s.", (int)i + 1, httpAddrString(&addr, s, sizeof(s)));
2089
2090 if ((lis = calloc(1, sizeof(cupsd_listener_t))) == NULL)
2091 {
2092 cupsdLogMessage(CUPSD_LOG_ERROR, "service_checkin: Unable to allocate listener: %s", strerror(errno));
2093 exit(EXIT_FAILURE);
2094 }
2095
2096 cupsArrayAdd(Listeners, lis);
2097
2098 memcpy(&lis->address, &addr, sizeof(lis->address));
2099 }
2100
2101 lis->fd = SD_LISTEN_FDS_START + i;
2102 lis->on_demand = 1;
2103
2104 # ifdef HAVE_SSL
2105 if (httpAddrPort(&(lis->address)) == 443)
2106 lis->encryption = HTTP_ENCRYPT_ALWAYS;
2107 # endif /* HAVE_SSL */
2108 }
2109 # endif /* HAVE_LAUNCH_ACTIVATE_SOCKET */
2110 }
2111
2112
2113 /*
2114 * 'service_checkout()' - Update the CUPS_KEEPALIVE file as needed.
2115 */
2116
2117 static void
2118 service_checkout(void)
2119 {
2120 int fd; /* File descriptor */
2121
2122
2123 /*
2124 * Create or remove the systemd path file based on whether there are active
2125 * jobs or shared printers to advertise...
2126 */
2127
2128 if (cupsArrayCount(ActiveJobs) || /* Active jobs */
2129 # ifdef HAVE_SYSTEMD
2130 WebInterface || /* Web interface enabled */
2131 # endif /* HAVE_SYSTEMD */
2132 (Browsing && BrowseLocalProtocols && cupsArrayCount(Printers)))
2133 /* Printers being shared */
2134 {
2135 cupsdLogMessage(CUPSD_LOG_DEBUG, "Creating keep-alive file \"" CUPS_KEEPALIVE "\".");
2136
2137 if ((fd = open(CUPS_KEEPALIVE, O_RDONLY | O_CREAT | O_EXCL, S_IRUSR)) >= 0)
2138 close(fd);
2139 }
2140 else
2141 {
2142 cupsdLogMessage(CUPSD_LOG_DEBUG, "Removing keep-alive file \"" CUPS_KEEPALIVE "\".");
2143
2144 unlink(CUPS_KEEPALIVE);
2145 }
2146 }
2147 #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */
2148
2149
2150 /*
2151 * 'usage()' - Show scheduler usage.
2152 */
2153
2154 static void
2155 usage(int status) /* O - Exit status */
2156 {
2157 FILE *fp = status ? stderr : stdout; /* Output file */
2158
2159
2160 _cupsLangPuts(fp, _("Usage: cupsd [options]"));
2161 _cupsLangPuts(fp, _("Options:"));
2162 _cupsLangPuts(fp, _(" -c cupsd.conf Set cupsd.conf file to use."));
2163 _cupsLangPuts(fp, _(" -f Run in the foreground."));
2164 _cupsLangPuts(fp, _(" -F Run in the foreground but "
2165 "detach from console."));
2166 _cupsLangPuts(fp, _(" -h Show this usage message."));
2167 _cupsLangPuts(fp, _(" -l Run cupsd on demand."));
2168 _cupsLangPuts(fp, _(" -t Test the configuration "
2169 "file."));
2170
2171 exit(status);
2172 }
2173
2174
2175 /*
2176 * End of "$Id: main.c 12248 2014-11-12 16:32:57Z msweet $".
2177 */
Unnamed repository; edit this file 'description' to name the repository.