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 "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
  39 extern 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  */
  56 static 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 **************************************************************************/
 135 static 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
 150 struct printing_queue_housekeeping_state {
 151         struct tevent_context *ev;
 152         struct messaging_context *msg;
 153 };
 154
 155 static 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
 178 static 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
 203 static void bq_reopen_logs(char *logfile)
 204 {
 205         if (logfile) {
 206                 lp_set_logfile(logfile);
 207         }
 208         reopen_logs();
 209 }
 210
 211 static 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
 221 static 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
 235 static 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
 252 static 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
 264 static 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
 282 static 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
 293 static 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
 308 static 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 /****************************************************************************
 321 main thread of the background lpq updater
 322 ****************************************************************************/
 323 pid_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 */
 438 bool 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
 479 void 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 }