source: vendor/current/source3/printing/queue_process.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 12.8 KB
Line 
1/*
2 Unix SMB/Netbios implementation.
3 Version 3.0
4 printing backend routines
5 Copyright (C) Andrew Tridgell 1992-2000
6 Copyright (C) Jeremy Allison 2002
7 Copyright (C) Simo Sorce 2011
8
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.
13
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.
18
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/>.
21*/
22
23#include "includes.h"
24#include "smbd/globals.h"
25#include "include/messages.h"
26#include "lib/util/util_process.h"
27#include "printing.h"
28#include "printing/pcap.h"
29#include "printing/queue_process.h"
30#include "serverid.h"
31#include "locking/proto.h"
32#include "smbd/smbd.h"
33#include "rpc_server/rpc_config.h"
34#include "printing/load.h"
35#include "rpc_server/spoolss/srv_spoolss_nt.h"
36#include "auth.h"
37#include "nt_printing.h"
38
39extern pid_t start_spoolssd(struct tevent_context *ev_ctx,
40 struct messaging_context *msg_ctx);
41
42/**
43 * @brief Purge stale printers and reload from pre-populated pcap cache.
44 *
45 * This function should normally only be called as a callback on a successful
46 * pcap_cache_reload().
47 *
48 * This function can cause DELETION of printers and drivers from our registry,
49 * so calling it on a failed pcap reload may REMOVE permanently all printers
50 * and drivers.
51 *
52 * @param[in] ev The event context.
53 *
54 * @param[in] msg_ctx The messaging context.
55 */
56static void delete_and_reload_printers_full(struct tevent_context *ev,
57 struct messaging_context *msg_ctx)
58{
59 struct auth_session_info *session_info = NULL;
60 struct spoolss_PrinterInfo2 *pinfo2 = NULL;
61 int n_services;
62 int pnum;
63 int snum;
64 const char *pname;
65 const char *sname;
66 NTSTATUS status;
67
68 n_services = lp_numservices();
69 pnum = lp_servicenumber(PRINTERS_NAME);
70
71 status = make_session_info_system(talloc_tos(), &session_info);
72 if (!NT_STATUS_IS_OK(status)) {
73 DEBUG(3, ("reload_printers: "
74 "Could not create system session_info\n"));
75 /* can't remove stale printers before we
76 * are fully initilized */
77 return;
78 }
79
80 /*
81 * Add default config for printers added to smb.conf file and remove
82 * stale printers
83 */
84 for (snum = 0; snum < n_services; snum++) {
85 /* avoid removing PRINTERS_NAME */
86 if (snum == pnum) {
87 continue;
88 }
89
90 /* skip no-printer services */
91 if (!snum_is_shared_printer(snum)) {
92 continue;
93 }
94
95 sname = lp_const_servicename(snum);
96 pname = lp_printername(session_info, snum);
97
98 /* check printer, but avoid removing non-autoloaded printers */
99 if (lp_autoloaded(snum) && !pcap_printername_ok(pname)) {
100 DEBUG(3, ("removing stale printer %s\n", pname));
101
102 if (is_printer_published(session_info, session_info,
103 msg_ctx,
104 NULL,
105 lp_servicename(session_info,
106 snum),
107 &pinfo2)) {
108 nt_printer_publish(session_info,
109 session_info,
110 msg_ctx,
111 pinfo2,
112 DSPRINT_UNPUBLISH);
113 TALLOC_FREE(pinfo2);
114 }
115 nt_printer_remove(session_info, session_info, msg_ctx,
116 pname);
117 } else {
118 DEBUG(8, ("Adding default registry entry for printer "
119 "[%s], if it doesn't exist.\n", sname));
120 nt_printer_add(session_info, session_info, msg_ctx,
121 sname);
122 }
123 }
124
125 /* finally, purge old snums */
126 delete_and_reload_printers(ev, msg_ctx);
127
128 TALLOC_FREE(session_info);
129}
130
131
132/****************************************************************************
133 Notify smbds of new printcap data
134**************************************************************************/
135static void reload_pcap_change_notify(struct tevent_context *ev,
136 struct messaging_context *msg_ctx)
137{
138 /*
139 * Reload the printers first in the background process so that
140 * newly added printers get default values created in the registry.
141 *
142 * This will block the process for some time (~1 sec per printer), but
143 * it doesn't block smbd's servering clients.
144 */
145 delete_and_reload_printers_full(ev, msg_ctx);
146
147 message_send_all(msg_ctx, MSG_PRINTER_PCAP, NULL, 0, NULL);
148}
149
150struct printing_queue_housekeeping_state {
151 struct tevent_context *ev;
152 struct messaging_context *msg;
153};
154
155static bool print_queue_housekeeping(const struct timeval *now, void *pvt)
156{
157 struct printing_queue_housekeeping_state *state =
158 talloc_get_type_abort(pvt,
159 struct printing_queue_housekeeping_state);
160 time_t printcap_cache_time = (time_t)lp_printcap_cache_time();
161 time_t t = time_mono(NULL);
162
163 DEBUG(5, ("print queue housekeeping\n"));
164
165 /* if periodic printcap rescan is enabled,
166 * see if it's time to reload */
167 if ((printcap_cache_time != 0) &&
168 (t >= (last_printer_reload_time + printcap_cache_time))) {
169 DEBUG( 3,( "Printcap cache time expired.\n"));
170 pcap_cache_reload(state->ev, state->msg,
171 &reload_pcap_change_notify);
172 last_printer_reload_time = t;
173 }
174
175 return true;
176}
177
178static bool printing_subsystem_queue_tasks(struct tevent_context *ev_ctx,
179 struct messaging_context *msg_ctx)
180{
181 struct printing_queue_housekeeping_state *state;
182
183 state = talloc_zero(ev_ctx, struct printing_queue_housekeeping_state);
184 if (state == NULL) {
185 DEBUG(0,("Could not talloc printing_queue_housekeeping_state\n"));
186 return false;
187 }
188 state->ev = ev_ctx;
189 state->msg = msg_ctx;
190
191 if (!(event_add_idle(ev_ctx, NULL,
192 timeval_set(SMBD_HOUSEKEEPING_INTERVAL, 0),
193 "print_queue_housekeeping",
194 print_queue_housekeeping,
195 state))) {
196 DEBUG(0,("Could not add print_queue_housekeeping event\n"));
197 return false;
198 }
199
200 return true;
201}
202
203static void bq_reopen_logs(char *logfile)
204{
205 if (logfile) {
206 lp_set_logfile(logfile);
207 }
208 reopen_logs();
209}
210
211static void bq_sig_term_handler(struct tevent_context *ev,
212 struct tevent_signal *se,
213 int signum,
214 int count,
215 void *siginfo,
216 void *private_data)
217{
218 exit_server_cleanly("termination signal");
219}
220
221static void bq_setup_sig_term_handler(void)
222{
223 struct tevent_signal *se;
224
225 se = tevent_add_signal(server_event_context(),
226 server_event_context(),
227 SIGTERM, 0,
228 bq_sig_term_handler,
229 NULL);
230 if (!se) {
231 exit_server("failed to setup SIGTERM handler");
232 }
233}
234
235static void bq_sig_hup_handler(struct tevent_context *ev,
236 struct tevent_signal *se,
237 int signum,
238 int count,
239 void *siginfo,
240 void *pvt)
241{
242 struct messaging_context *msg_ctx;
243
244 msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
245 change_to_root_user();
246
247 DEBUG(1, ("Reloading pcap cache after SIGHUP\n"));
248 pcap_cache_reload(ev, msg_ctx, &reload_pcap_change_notify);
249 bq_reopen_logs(NULL);
250}
251
252static void bq_setup_sig_hup_handler(struct tevent_context *ev,
253 struct messaging_context *msg_ctx)
254{
255 struct tevent_signal *se;
256
257 se = tevent_add_signal(ev, ev, SIGHUP, 0, bq_sig_hup_handler,
258 msg_ctx);
259 if (!se) {
260 exit_server("failed to setup SIGHUP handler");
261 }
262}
263
264static void bq_sig_chld_handler(struct tevent_context *ev_ctx,
265 struct tevent_signal *se,
266 int signum, int count,
267 void *siginfo, void *pvt)
268{
269 int status;
270 pid_t pid;
271
272 pid = sys_waitpid(-1, &status, WNOHANG);
273 if (WIFEXITED(status)) {
274 DEBUG(6, ("Bq child process %d terminated with %d\n",
275 (int)pid, WEXITSTATUS(status)));
276 } else {
277 DEBUG(3, ("Bq child process %d terminated abnormally\n",
278 (int)pid));
279 }
280}
281
282static void bq_setup_sig_chld_handler(struct tevent_context *ev_ctx)
283{
284 struct tevent_signal *se;
285
286 se = tevent_add_signal(ev_ctx, ev_ctx, SIGCHLD, 0,
287 bq_sig_chld_handler, NULL);
288 if (!se) {
289 exit_server("failed to setup SIGCHLD handler");
290 }
291}
292
293static void bq_smb_conf_updated(struct messaging_context *msg_ctx,
294 void *private_data,
295 uint32_t msg_type,
296 struct server_id server_id,
297 DATA_BLOB *data)
298{
299 struct tevent_context *ev_ctx =
300 talloc_get_type_abort(private_data, struct tevent_context);
301
302 DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
303 "updated. Reloading.\n"));
304 change_to_root_user();
305 pcap_cache_reload(ev_ctx, msg_ctx, &reload_pcap_change_notify);
306}
307
308static void printing_pause_fd_handler(struct tevent_context *ev,
309 struct tevent_fd *fde,
310 uint16_t flags,
311 void *private_data)
312{
313 /*
314 * If pause_pipe[1] is closed it means the parent smbd
315 * and children exited or aborted.
316 */
317 exit_server_cleanly(NULL);
318}
319
320/****************************************************************************
321main thread of the background lpq updater
322****************************************************************************/
323pid_t start_background_queue(struct tevent_context *ev,
324 struct messaging_context *msg_ctx,
325 char *logfile)
326{
327 pid_t pid;
328
329 /* Use local variables for this as we don't
330 * need to save the parent side of this, just
331 * ensure it closes when the process exits.
332 */
333 int pause_pipe[2];
334
335 DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
336
337 if (pipe(pause_pipe) == -1) {
338 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
339 exit(1);
340 }
341
342 /*
343 * Block signals before forking child as it will have to
344 * set its own handlers. Child will re-enable SIGHUP as
345 * soon as the handlers are set up.
346 */
347 BlockSignals(true, SIGTERM);
348 BlockSignals(true, SIGHUP);
349
350 pid = fork();
351
352 /* parent or error */
353 if (pid != 0) {
354 /* Re-enable SIGHUP before returnig */
355 BlockSignals(false, SIGTERM);
356 BlockSignals(false, SIGHUP);
357 return pid;
358 }
359
360 if (pid == -1) {
361 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
362 exit(1);
363 }
364
365 if (pid == 0) {
366 struct tevent_fd *fde;
367 int ret;
368 NTSTATUS status;
369
370 /* Child. */
371 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
372
373 close(pause_pipe[0]);
374 pause_pipe[0] = -1;
375
376 status = smbd_reinit_after_fork(msg_ctx, ev, true, "lpqd");
377
378 if (!NT_STATUS_IS_OK(status)) {
379 DEBUG(0,("reinit_after_fork() failed\n"));
380 smb_panic("reinit_after_fork() failed");
381 }
382
383 bq_reopen_logs(logfile);
384 bq_setup_sig_term_handler();
385 bq_setup_sig_hup_handler(ev, msg_ctx);
386 bq_setup_sig_chld_handler(ev);
387
388 BlockSignals(false, SIGTERM);
389 BlockSignals(false, SIGHUP);
390
391 if (!printing_subsystem_queue_tasks(ev, msg_ctx)) {
392 exit(1);
393 }
394
395 if (!serverid_register(messaging_server_id(msg_ctx),
396 FLAG_MSG_GENERAL |
397 FLAG_MSG_PRINT_GENERAL)) {
398 exit(1);
399 }
400
401 if (!locking_init()) {
402 exit(1);
403 }
404 messaging_register(msg_ctx, ev, MSG_SMB_CONF_UPDATED,
405 bq_smb_conf_updated);
406 messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
407 print_queue_receive);
408 /* Remove previous forwarder message set in parent. */
409 messaging_deregister(msg_ctx, MSG_PRINTER_DRVUPGRADE, NULL);
410
411 messaging_register(msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE,
412 do_drv_upgrade_printer);
413
414 fde = tevent_add_fd(ev, ev, pause_pipe[1], TEVENT_FD_READ,
415 printing_pause_fd_handler,
416 NULL);
417 if (!fde) {
418 DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
419 smb_panic("tevent_add_fd() failed for pause_pipe");
420 }
421
422 pcap_cache_reload(ev, msg_ctx, &reload_pcap_change_notify);
423
424 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
425 ret = tevent_loop_wait(ev);
426 /* should not be reached */
427 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
428 ret, (ret == 0) ? "out of events" : strerror(errno)));
429 exit(1);
430 }
431
432 close(pause_pipe[1]);
433
434 return pid;
435}
436
437/* Run before the parent forks */
438bool printing_subsystem_init(struct tevent_context *ev_ctx,
439 struct messaging_context *msg_ctx,
440 bool start_daemons,
441 bool background_queue)
442{
443 pid_t pid = -1;
444
445 if (!print_backend_init(msg_ctx)) {
446 return false;
447 }
448
449 /* start spoolss daemon */
450 /* start as a separate daemon only if enabled */
451 if (start_daemons && rpc_spoolss_daemon() == RPC_DAEMON_FORK) {
452
453 pid = start_spoolssd(ev_ctx, msg_ctx);
454
455 } else if (start_daemons && background_queue) {
456
457 pid = start_background_queue(ev_ctx, msg_ctx, NULL);
458
459 } else {
460 bool ret;
461
462 ret = printing_subsystem_queue_tasks(ev_ctx, msg_ctx);
463
464 /* Publish nt printers, this requires a working winreg pipe */
465 pcap_cache_reload(ev_ctx, msg_ctx,
466 &delete_and_reload_printers_full);
467
468 return ret;
469 }
470
471 if (pid == -1) {
472 return false;
473 }
474 background_lpq_updater_pid = pid;
475
476 return true;
477}
478
479void printing_subsystem_update(struct tevent_context *ev_ctx,
480 struct messaging_context *msg_ctx,
481 bool force)
482{
483 if (background_lpq_updater_pid != -1) {
484 if (pcap_cache_loaded(NULL)) {
485 load_printers(ev_ctx, msg_ctx);
486 }
487 if (force) {
488 /* Send a sighup to the background process.
489 * this will force it to reload printers */
490 kill(background_lpq_updater_pid, SIGHUP);
491 }
492 return;
493 }
494
495 pcap_cache_reload(ev_ctx, msg_ctx,
496 &delete_and_reload_printers_full);
497}
Note: See TracBrowser for help on using the repository browser.