source3/printing/queue_process.c

   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 "printing.h"
  27 #include "printing/pcap.h"
  28 #include "printing/queue_process.h"
  29 #include "serverid.h"
  30 #include "locking/proto.h"
  31 #include "smbd/proto.h"
  32 #include "rpc_server/rpc_service_setup.h"
  33
  34 extern pid_t start_spoolssd(struct event_context *ev_ctx,
  35                             struct messaging_context *msg_ctx);
  36
  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)
  42 {
  43         message_send_all(msg_ctx, MSG_PRINTER_PCAP, NULL, 0, NULL);
  44 }
  45
  46 static bool print_queue_housekeeping(const struct timeval *now, void *pvt)
  47 {
  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);
  52
  53         DEBUG(5, ("print queue housekeeping\n"));
  54
  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),
  61                                   msg_ctx,
  62                                   &reload_pcap_change_notify);
  63                 last_printer_reload_time = t;
  64         }
  65
  66         return true;
  67 }
  68
  69 static bool printing_subsystem_queue_tasks(struct tevent_context *ev_ctx,
  70                                            struct messaging_context *msg_ctx)
  71 {
  72         if (!(event_add_idle(ev_ctx, NULL,
  73                              timeval_set(SMBD_HOUSEKEEPING_INTERVAL, 0),
  74                              "print_queue_housekeeping",
  75                              print_queue_housekeeping,
  76                              msg_ctx))) {
  77                 DEBUG(0, ("Could not add print_queue_housekeeping event\n"));
  78                 return false;
  79         }
  80
  81         return true;
  82 }
  83
  84 static void bq_reopen_logs(char *logfile)
  85 {
  86         if (logfile) {
  87                 lp_set_logfile(logfile);
  88         }
  89         reopen_logs();
  90 }
  91
  92 static void bq_sig_term_handler(struct tevent_context *ev,
  93                                 struct tevent_signal *se,
  94                                 int signum,
  95                                 int count,
  96                                 void *siginfo,
  97                                 void *private_data)
  98 {
  99         exit_server_cleanly("termination signal");
 100 }
 101
 102 static void bq_setup_sig_term_handler(void)
 103 {
 104         struct tevent_signal *se;
 105
 106         se = tevent_add_signal(server_event_context(),
 107                                server_event_context(),
 108                                SIGTERM, 0,
 109                                bq_sig_term_handler,
 110                                NULL);
 111         if (!se) {
 112                 exit_server("failed to setup SIGTERM handler");
 113         }
 114 }
 115
 116 static void bq_sig_hup_handler(struct tevent_context *ev,
 117                                 struct tevent_signal *se,
 118                                 int signum,
 119                                 int count,
 120                                 void *siginfo,
 121                                 void *pvt)
 122 {
 123         struct messaging_context *msg_ctx;
 124
 125         msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
 126         change_to_root_user();
 127
 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);
 131 }
 132
 133 static void bq_setup_sig_hup_handler(struct tevent_context *ev,
 134                                      struct messaging_context *msg_ctx)
 135 {
 136         struct tevent_signal *se;
 137
 138         se = tevent_add_signal(ev, ev, SIGHUP, 0, bq_sig_hup_handler,
 139                                msg_ctx);
 140         if (!se) {
 141                 exit_server("failed to setup SIGHUP handler");
 142         }
 143 }
 144
 145 static void bq_smb_conf_updated(struct messaging_context *msg_ctx,
 146                                 void *private_data,
 147                                 uint32_t msg_type,
 148                                 struct server_id server_id,
 149                                 DATA_BLOB *data)
 150 {
 151         struct tevent_context *ev_ctx =
 152                 talloc_get_type_abort(private_data, struct tevent_context);
 153
 154         DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
 155                   "updated. Reloading.\n"));
 156         change_to_root_user();
 157         pcap_cache_reload(ev_ctx, msg_ctx, &reload_pcap_change_notify);
 158 }
 159
 160 static void printing_pause_fd_handler(struct tevent_context *ev,
 161                                       struct tevent_fd *fde,
 162                                       uint16_t flags,
 163                                       void *private_data)
 164 {
 165         /*
 166          * If pause_pipe[1] is closed it means the parent smbd
 167          * and children exited or aborted.
 168          */
 169         exit_server_cleanly(NULL);
 170 }
 171
 172 /****************************************************************************
 173 main thread of the background lpq updater
 174 ****************************************************************************/
 175 pid_t start_background_queue(struct tevent_context *ev,
 176                              struct messaging_context *msg_ctx,
 177                              char *logfile)
 178 {
 179         pid_t pid;
 180
 181         /* Use local variables for this as we don't
 182          * need to save the parent side of this, just
 183          * ensure it closes when the process exits.
 184          */
 185         int pause_pipe[2];
 186
 187         DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
 188
 189         if (pipe(pause_pipe) == -1) {
 190                 DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
 191                 exit(1);
 192         }
 193
 194         /*
 195          * Block signals before forking child as it will have to
 196          * set its own handlers. Child will re-enable SIGHUP as
 197          * soon as the handlers are set up.
 198          */
 199         BlockSignals(true, SIGTERM);
 200         BlockSignals(true, SIGHUP);
 201
 202         pid = sys_fork();
 203
 204         /* parent or error */
 205         if (pid != 0) {
 206                 /* Re-enable SIGHUP before returnig */
 207                 BlockSignals(false, SIGTERM);
 208                 BlockSignals(false, SIGHUP);
 209                 return pid;
 210         }
 211
 212         if (pid == -1) {
 213                 DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
 214                 exit(1);
 215         }
 216
 217         if (pid == 0) {
 218                 struct tevent_fd *fde;
 219                 int ret;
 220                 NTSTATUS status;
 221
 222                 /* Child. */
 223                 DEBUG(5,("start_background_queue: background LPQ thread started\n"));
 224
 225                 close(pause_pipe[0]);
 226                 pause_pipe[0] = -1;
 227
 228                 status = reinit_after_fork(msg_ctx, ev, procid_self(), true);
 229
 230                 if (!NT_STATUS_IS_OK(status)) {
 231                         DEBUG(0,("reinit_after_fork() failed\n"));
 232                         smb_panic("reinit_after_fork() failed");
 233                 }
 234
 235                 bq_reopen_logs(logfile);
 236                 bq_setup_sig_term_handler();
 237                 bq_setup_sig_hup_handler(ev, msg_ctx);
 238
 239                 BlockSignals(false, SIGTERM);
 240                 BlockSignals(false, SIGHUP);
 241
 242                 if (!pcap_cache_loaded()) {
 243                         pcap_cache_reload(ev, msg_ctx, &reload_printers);
 244                 }
 245
 246                 if (!printing_subsystem_queue_tasks(ev, msg_ctx)) {
 247                         exit(1);
 248                 }
 249
 250                 if (!serverid_register(procid_self(),
 251                                        FLAG_MSG_GENERAL|FLAG_MSG_SMBD
 252                                        |FLAG_MSG_PRINT_GENERAL)) {
 253                         exit(1);
 254                 }
 255
 256                 if (!locking_init()) {
 257                         exit(1);
 258                 }
 259                 messaging_register(msg_ctx, ev, MSG_SMB_CONF_UPDATED,
 260                                    bq_smb_conf_updated);
 261                 messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
 262                                    print_queue_receive);
 263
 264                 fde = tevent_add_fd(ev, ev, pause_pipe[1], TEVENT_FD_READ,
 265                                     printing_pause_fd_handler,
 266                                     NULL);
 267                 if (!fde) {
 268                         DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
 269                         smb_panic("tevent_add_fd() failed for pause_pipe");
 270                 }
 271
 272                 DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
 273                 ret = tevent_loop_wait(ev);
 274                 /* should not be reached */
 275                 DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
 276                          ret, (ret == 0) ? "out of events" : strerror(errno)));
 277                 exit(1);
 278         }
 279
 280         close(pause_pipe[1]);
 281
 282         return pid;
 283 }
 284
 285 /* Run before the parent forks */
 286 bool printing_subsystem_init(struct tevent_context *ev_ctx,
 287                              struct messaging_context *msg_ctx,
 288                              bool start_daemons,
 289                              bool background_queue)
 290 {
 291         enum rpc_service_mode_e spoolss_mode = rpc_spoolss_mode();
 292         pid_t pid = -1;
 293
 294         if (!print_backend_init(msg_ctx)) {
 295                 return false;
 296         }
 297
 298         /* start spoolss daemon */
 299         /* start as a separate daemon only if enabled */
 300         if (start_daemons && spoolss_mode == RPC_SERVICE_MODE_DAEMON) {
 301
 302                 pid = start_spoolssd(ev_ctx, msg_ctx);
 303
 304         } else if (start_daemons && background_queue) {
 305
 306                 pid = start_background_queue(ev_ctx, msg_ctx, NULL);
 307
 308         } else {
 309                 bool ret;
 310
 311                 ret = printing_subsystem_queue_tasks(ev_ctx, msg_ctx);
 312
 313                 /* Publish nt printers, this requires a working winreg pipe */
 314                 pcap_cache_reload(ev_ctx, msg_ctx, &reload_printers);
 315
 316                 return ret;
 317         }
 318
 319         if (pid == -1) {
 320                 return false;
 321         }
 322         background_lpq_updater_pid = pid;
 323
 324         return true;
 325 }
 326
 327 void printing_subsystem_update(struct tevent_context *ev_ctx,
 328                                struct messaging_context *msg_ctx,
 329                                bool force)
 330 {
 331         if (background_lpq_updater_pid != -1) {
 332                 if (force) {
 333                         /* Send a sighup to the background process.
 334                          * this will force it to reload printers */
 335                         kill(background_lpq_updater_pid, SIGHUP);
 336                 }
 337                 return;
 338         }
 339
 340         pcap_cache_reload(ev_ctx, msg_ctx, &reload_pcap_change_notify);
 341 }