2 Unix SMB/Netbios implementation.
4 printing backend routines
5 Copyright (C) Andrew Tridgell 1992-2000
6 Copyright (C) Jeremy Allison 2002
7 Copyright (C) Simo Sorce 2011
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "smbd/globals.h"
25 #include "include/messages.h"
27 #include "printing/pcap.h"
28 #include "printing/queue_process.h"
30 #include "locking/proto.h"
31 #include "smbd/proto.h"
32 #include "rpc_server/rpc_service_setup.h"
34 extern pid_t start_spoolssd(struct event_context *ev_ctx,
35 struct messaging_context *msg_ctx);
37 /****************************************************************************
38 Notify smbds of new printcap data
39 **************************************************************************/
40 static void reload_pcap_change_notify(struct tevent_context *ev,
41 struct messaging_context *msg_ctx)
43 message_send_all(msg_ctx, MSG_PRINTER_PCAP, NULL, 0, NULL);
46 static bool print_queue_housekeeping(const struct timeval *now, void *pvt)
48 struct messaging_context *msg_ctx =
49 talloc_get_type_abort(pvt, struct messaging_context);
50 time_t printcap_cache_time = (time_t)lp_printcap_cache_time();
51 time_t t = time_mono(NULL);
53 DEBUG(5, ("print queue housekeeping\n"));
55 /* if periodic printcap rescan is enabled,
56 * see if it's time to reload */
57 if ((printcap_cache_time != 0) &&
58 (t >= (last_printer_reload_time + printcap_cache_time))) {
59 DEBUG( 3,( "Printcap cache time expired.\n"));
60 pcap_cache_reload(messaging_event_context(msg_ctx),
62 &reload_pcap_change_notify);
63 last_printer_reload_time = t;
69 static bool printing_subsystem_queue_tasks(struct tevent_context *ev_ctx,
70 struct messaging_context *msg_ctx)
72 if (!(event_add_idle(ev_ctx, NULL,
73 timeval_set(SMBD_HOUSEKEEPING_INTERVAL, 0),
74 "print_queue_housekeeping",
75 print_queue_housekeeping,
77 DEBUG(0, ("Could not add print_queue_housekeeping event\n"));
84 static void bq_reopen_logs(char *logfile)
87 lp_set_logfile(logfile);
92 static void bq_sig_term_handler(struct tevent_context *ev,
93 struct tevent_signal *se,
99 exit_server_cleanly("termination signal");
102 static void bq_setup_sig_term_handler(void)
104 struct tevent_signal *se;
106 se = tevent_add_signal(server_event_context(),
107 server_event_context(),
112 exit_server("failed to setup SIGTERM handler");
116 static void bq_sig_hup_handler(struct tevent_context *ev,
117 struct tevent_signal *se,
123 struct messaging_context *msg_ctx;
125 msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
126 change_to_root_user();
128 DEBUG(1, ("Reloading pcap cache after SIGHUP\n"));
129 pcap_cache_reload(ev, msg_ctx, &reload_pcap_change_notify);
130 bq_reopen_logs(NULL);
133 static void bq_setup_sig_hup_handler(struct tevent_context *ev,
134 struct messaging_context *msg_ctx)
136 struct tevent_signal *se;
138 se = tevent_add_signal(ev, ev, SIGHUP, 0, bq_sig_hup_handler,
141 exit_server("failed to setup SIGHUP handler");
145 static void bq_sig_chld_handler(struct tevent_context *ev_ctx,
146 struct tevent_signal *se,
147 int signum, int count,
148 void *siginfo, void *pvt)
153 pid = sys_waitpid(-1, &status, WNOHANG);
154 if (WIFEXITED(status)) {
155 DEBUG(6, ("Bq child process %d terminated with %d\n",
156 (int)pid, WEXITSTATUS(status)));
158 DEBUG(3, ("Bq child process %d terminated abnormally\n",
163 static void bq_setup_sig_chld_handler(struct tevent_context *ev_ctx)
165 struct tevent_signal *se;
167 se = tevent_add_signal(ev_ctx, ev_ctx, SIGCHLD, 0,
168 bq_sig_chld_handler, NULL);
170 exit_server("failed to setup SIGCHLD handler");
174 static void bq_smb_conf_updated(struct messaging_context *msg_ctx,
177 struct server_id server_id,
180 struct tevent_context *ev_ctx =
181 talloc_get_type_abort(private_data, struct tevent_context);
183 DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
184 "updated. Reloading.\n"));
185 change_to_root_user();
186 pcap_cache_reload(ev_ctx, msg_ctx, &reload_pcap_change_notify);
189 static void printing_pause_fd_handler(struct tevent_context *ev,
190 struct tevent_fd *fde,
195 * If pause_pipe[1] is closed it means the parent smbd
196 * and children exited or aborted.
198 exit_server_cleanly(NULL);
201 /****************************************************************************
202 main thread of the background lpq updater
203 ****************************************************************************/
204 pid_t start_background_queue(struct tevent_context *ev,
205 struct messaging_context *msg_ctx,
210 /* Use local variables for this as we don't
211 * need to save the parent side of this, just
212 * ensure it closes when the process exits.
216 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
218 if (pipe(pause_pipe) == -1) {
219 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
224 * Block signals before forking child as it will have to
225 * set its own handlers. Child will re-enable SIGHUP as
226 * soon as the handlers are set up.
228 BlockSignals(true, SIGTERM);
229 BlockSignals(true, SIGHUP);
233 /* parent or error */
235 /* Re-enable SIGHUP before returnig */
236 BlockSignals(false, SIGTERM);
237 BlockSignals(false, SIGHUP);
242 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
247 struct tevent_fd *fde;
252 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
254 close(pause_pipe[0]);
257 status = reinit_after_fork(msg_ctx, ev, procid_self(), true);
259 if (!NT_STATUS_IS_OK(status)) {
260 DEBUG(0,("reinit_after_fork() failed\n"));
261 smb_panic("reinit_after_fork() failed");
264 bq_reopen_logs(logfile);
265 bq_setup_sig_term_handler();
266 bq_setup_sig_hup_handler(ev, msg_ctx);
267 bq_setup_sig_chld_handler(ev);
269 BlockSignals(false, SIGTERM);
270 BlockSignals(false, SIGHUP);
272 if (!printing_subsystem_queue_tasks(ev, msg_ctx)) {
276 if (!serverid_register(procid_self(),
277 FLAG_MSG_GENERAL|FLAG_MSG_SMBD
278 |FLAG_MSG_PRINT_GENERAL)) {
282 if (!locking_init()) {
285 messaging_register(msg_ctx, ev, MSG_SMB_CONF_UPDATED,
286 bq_smb_conf_updated);
287 messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
288 print_queue_receive);
290 fde = tevent_add_fd(ev, ev, pause_pipe[1], TEVENT_FD_READ,
291 printing_pause_fd_handler,
294 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
295 smb_panic("tevent_add_fd() failed for pause_pipe");
298 pcap_cache_reload(ev, msg_ctx, &reload_pcap_change_notify);
300 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
301 ret = tevent_loop_wait(ev);
302 /* should not be reached */
303 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
304 ret, (ret == 0) ? "out of events" : strerror(errno)));
308 close(pause_pipe[1]);
313 /* Run before the parent forks */
314 bool printing_subsystem_init(struct tevent_context *ev_ctx,
315 struct messaging_context *msg_ctx,
317 bool background_queue)
319 enum rpc_service_mode_e spoolss_mode = rpc_spoolss_mode();
322 if (!print_backend_init(msg_ctx)) {
326 /* start spoolss daemon */
327 /* start as a separate daemon only if enabled */
328 if (start_daemons && spoolss_mode == RPC_SERVICE_MODE_DAEMON) {
330 pid = start_spoolssd(ev_ctx, msg_ctx);
332 } else if (start_daemons && background_queue) {
334 pid = start_background_queue(ev_ctx, msg_ctx, NULL);
339 ret = printing_subsystem_queue_tasks(ev_ctx, msg_ctx);
341 /* Publish nt printers, this requires a working winreg pipe */
342 pcap_cache_reload(ev_ctx, msg_ctx, &reload_printers);
350 background_lpq_updater_pid = pid;
355 void printing_subsystem_update(struct tevent_context *ev_ctx,
356 struct messaging_context *msg_ctx,
359 if (background_lpq_updater_pid != -1) {
361 /* Send a sighup to the background process.
362 * this will force it to reload printers */
363 kill(background_lpq_updater_pid, SIGHUP);
368 pcap_cache_reload(ev_ctx, msg_ctx, &reload_pcap_change_notify);