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 <spawn.h>
  25 #include "smbd/globals.h"
  26 #include "include/messages.h"
  27 #include "lib/util/util_process.h"
  28 #include "lib/util/sys_rw.h"
  29 #include "printing.h"
  30 #include "printing/pcap.h"
  31 #include "printing/printer_list.h"
  32 #include "printing/queue_process.h"
  33 #include "locking/proto.h"
  34 #include "locking/share_mode_lock.h"
  35 #include "smbd/smbd.h"
  36 #include "rpc_server/rpc_config.h"
  37 #include "printing/load.h"
  38 #include "rpc_server/spoolss/srv_spoolss_nt.h"
  39 #include "auth.h"
  40 #include "nt_printing.h"
  41 #include "util_event.h"
  42 #include "lib/global_contexts.h"
  43 #include "lib/util/pidfile.h"
  44
  45 /**
  46  * @brief Purge stale printers and reload from pre-populated pcap cache.
  47  *
  48  * This function should normally only be called as a callback on a successful
  49  * pcap_cache_reload().
  50  *
  51  * This function can cause DELETION of printers and drivers from our registry,
  52  * so calling it on a failed pcap reload may REMOVE permanently all printers
  53  * and drivers.
  54  *
  55  * @param[in] ev        The event context.
  56  *
  57  * @param[in] msg_ctx   The messaging context.
  58  */
  59 static void delete_and_reload_printers_full(struct tevent_context *ev,
  60                                             struct messaging_context *msg_ctx)
  61 {
  62         struct auth_session_info *session_info = NULL;
  63         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
  64         const struct loadparm_substitution *lp_sub =
  65                 loadparm_s3_global_substitution();
  66         int n_services;
  67         int pnum;
  68         int snum;
  69         const char *pname;
  70         const char *sname;
  71         NTSTATUS status;
  72
  73         n_services = lp_numservices();
  74         pnum = lp_servicenumber(PRINTERS_NAME);
  75
  76         status = make_session_info_system(talloc_tos(), &session_info);
  77         if (!NT_STATUS_IS_OK(status)) {
  78                 DEBUG(3, ("reload_printers: "
  79                           "Could not create system session_info\n"));
  80                 /* can't remove stale printers before we
  81                  * are fully initialized */
  82                 return;
  83         }
  84
  85         /*
  86          * Add default config for printers added to smb.conf file and remove
  87          * stale printers
  88          */
  89         for (snum = 0; snum < n_services; snum++) {
  90                 /* avoid removing PRINTERS_NAME */
  91                 if (snum == pnum) {
  92                         continue;
  93                 }
  94
  95                 /* skip no-printer services */
  96                 if (!snum_is_shared_printer(snum)) {
  97                         continue;
  98                 }
  99
 100                 sname = lp_const_servicename(snum);
 101                 pname = lp_printername(session_info, lp_sub, snum);
 102
 103                 /* check printer, but avoid removing non-autoloaded printers */
 104                 if (lp_autoloaded(snum) &&
 105                     !printer_list_printername_exists(pname)) {
 106                         DEBUG(3, ("removing stale printer %s\n", pname));
 107
 108                         if (is_printer_published(session_info, session_info,
 109                                                  msg_ctx,
 110                                                  NULL,
 111                                                  lp_servicename(session_info,
 112                                                                 lp_sub,
 113                                                                 snum),
 114                                                  &pinfo2)) {
 115                                 nt_printer_publish(session_info,
 116                                                    session_info,
 117                                                    msg_ctx,
 118                                                    pinfo2,
 119                                                    DSPRINT_UNPUBLISH);
 120                                 TALLOC_FREE(pinfo2);
 121                         }
 122                         nt_printer_remove(session_info, session_info, msg_ctx,
 123                                           pname);
 124                 } else {
 125                         DEBUG(8, ("Adding default registry entry for printer "
 126                                   "[%s], if it doesn't exist.\n", sname));
 127                         nt_printer_add(session_info, session_info, msg_ctx,
 128                                        sname);
 129                 }
 130         }
 131
 132         /* finally, purge old snums */
 133         delete_and_reload_printers();
 134
 135         TALLOC_FREE(session_info);
 136 }
 137
 138
 139 /****************************************************************************
 140  Notify smbds of new printcap data
 141 **************************************************************************/
 142 static void reload_pcap_change_notify(struct tevent_context *ev,
 143                                struct messaging_context *msg_ctx)
 144 {
 145         /*
 146          * Reload the printers first in the background process so that
 147          * newly added printers get default values created in the registry.
 148          *
 149          * This will block the process for some time (~1 sec per printer), but
 150          * it doesn't block smbd's serving clients.
 151          */
 152         delete_and_reload_printers_full(ev, msg_ctx);
 153
 154         messaging_send_all(msg_ctx, MSG_PRINTER_PCAP, NULL, 0);
 155 }
 156
 157 struct bq_state {
 158         struct tevent_context *ev;
 159         struct messaging_context *msg;
 160         struct idle_event *housekeep;
 161         struct tevent_signal *sighup_handler;
 162         struct tevent_signal *sigchld_handler;
 163 };
 164
 165 static bool print_queue_housekeeping(const struct timeval *now, void *pvt)
 166 {
 167         struct bq_state *state;
 168
 169         state = talloc_get_type_abort(pvt, struct bq_state);
 170
 171         DEBUG(5, ("print queue housekeeping\n"));
 172         pcap_cache_reload(state->ev, state->msg, reload_pcap_change_notify);
 173
 174         return true;
 175 }
 176
 177 static bool printing_subsystem_queue_tasks(struct bq_state *state)
 178 {
 179         uint32_t housekeeping_period = lp_printcap_cache_time();
 180
 181         /* cancel any existing housekeeping event */
 182         TALLOC_FREE(state->housekeep);
 183
 184         if ((housekeeping_period == 0) || !lp_load_printers()) {
 185                 DEBUG(4, ("background print queue housekeeping disabled\n"));
 186                 return true;
 187         }
 188
 189         state->housekeep = event_add_idle(
 190                 state->ev,
 191                 NULL,
 192                 tevent_timeval_set(housekeeping_period, 0),
 193                 "print_queue_housekeeping",
 194                 print_queue_housekeeping,
 195                 state);
 196         if (state->housekeep == NULL) {
 197                 DEBUG(0,("Could not add print_queue_housekeeping event\n"));
 198                 return false;
 199         }
 200
 201         return true;
 202 }
 203
 204 static void bq_reopen_logs(char *logfile)
 205 {
 206         if (logfile) {
 207                 lp_set_logfile(logfile);
 208         }
 209         reopen_logs();
 210 }
 211
 212 static void bq_sig_hup_handler(struct tevent_context *ev,
 213                                 struct tevent_signal *se,
 214                                 int signum,
 215                                 int count,
 216                                 void *siginfo,
 217                                 void *pvt)
 218 {
 219         struct bq_state *state;
 220
 221         state = talloc_get_type_abort(pvt, struct bq_state);
 222         change_to_root_user();
 223
 224         DEBUG(1, ("Reloading pcap cache after SIGHUP\n"));
 225         pcap_cache_reload(state->ev, state->msg,
 226                           reload_pcap_change_notify);
 227         printing_subsystem_queue_tasks(state);
 228         bq_reopen_logs(NULL);
 229 }
 230
 231 static void bq_sig_chld_handler(struct tevent_context *ev_ctx,
 232                                 struct tevent_signal *se,
 233                                 int signum, int count,
 234                                 void *siginfo, void *pvt)
 235 {
 236         int status;
 237         pid_t pid;
 238
 239         do {
 240                 do {
 241                         pid = waitpid(-1, &status, WNOHANG);
 242                 } while ((pid == -1) && (errno == EINTR));
 243
 244                 if (WIFEXITED(status)) {
 245                         DBG_INFO("Bq child process %d terminated with %d\n",
 246                                  (int)pid,
 247                                  WEXITSTATUS(status));
 248                 } else {
 249                         DBG_NOTICE("Bq child process %d terminated abnormally\n",
 250                                    (int)pid);
 251                 }
 252         } while (pid > 0);
 253 }
 254
 255 static void bq_smb_conf_updated(struct messaging_context *msg_ctx,
 256                                 void *private_data,
 257                                 uint32_t msg_type,
 258                                 struct server_id server_id,
 259                                 DATA_BLOB *data)
 260 {
 261         struct bq_state *state;
 262
 263         state = talloc_get_type_abort(private_data, struct bq_state);
 264
 265         DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
 266                   "updated. Reloading.\n"));
 267         change_to_root_user();
 268         pcap_cache_reload(state->ev, msg_ctx, reload_pcap_change_notify);
 269         printing_subsystem_queue_tasks(state);
 270 }
 271
 272 static int bq_state_destructor(struct bq_state *s)
 273 {
 274         struct messaging_context *msg_ctx = s->msg;
 275         TALLOC_FREE(s->sighup_handler);
 276         TALLOC_FREE(s->sigchld_handler);
 277         messaging_deregister(msg_ctx, MSG_PRINTER_DRVUPGRADE, NULL);
 278         messaging_deregister(msg_ctx, MSG_PRINTER_UPDATE, NULL);
 279         messaging_deregister(msg_ctx, MSG_SMB_CONF_UPDATED, s);
 280         return 0;
 281 }
 282
 283 struct bq_state *register_printing_bq_handlers(
 284         TALLOC_CTX *mem_ctx,
 285         struct messaging_context *msg_ctx)
 286 {
 287         struct bq_state *state = NULL;
 288         NTSTATUS status;
 289         bool ok;
 290
 291         state = talloc_zero(mem_ctx, struct bq_state);
 292         if (state == NULL) {
 293                 return NULL;
 294         }
 295         state->ev = messaging_tevent_context(msg_ctx);
 296         state->msg = msg_ctx;
 297
 298         status = messaging_register(
 299                 msg_ctx, state, MSG_SMB_CONF_UPDATED, bq_smb_conf_updated);
 300         if (!NT_STATUS_IS_OK(status)) {
 301                 goto fail;
 302         }
 303         status = messaging_register(
 304                 msg_ctx, NULL, MSG_PRINTER_UPDATE, print_queue_receive);
 305         if (!NT_STATUS_IS_OK(status)) {
 306                 goto fail_dereg_smb_conf_updated;
 307         }
 308         status = messaging_register(
 309                 msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE, do_drv_upgrade_printer);
 310         if (!NT_STATUS_IS_OK(status)) {
 311                 goto fail_dereg_printer_update;
 312         }
 313
 314         state->sighup_handler = tevent_add_signal(
 315                 state->ev, state, SIGHUP, 0, bq_sig_hup_handler, state);
 316         if (state->sighup_handler == NULL) {
 317                 goto fail_dereg_printer_drvupgrade;
 318         }
 319         state->sigchld_handler = tevent_add_signal(
 320                 state->ev, state, SIGCHLD, 0, bq_sig_chld_handler, NULL);
 321         if (state->sigchld_handler == NULL) {
 322                 goto fail_free_handlers;
 323         }
 324
 325         /* Initialize the printcap cache as soon as the daemon starts. */
 326         pcap_cache_reload(state->ev, state->msg, reload_pcap_change_notify);
 327
 328         ok = printing_subsystem_queue_tasks(state);
 329         if (!ok) {
 330                 goto fail_free_handlers;
 331         }
 332
 333         talloc_set_destructor(state, bq_state_destructor);
 334
 335         return state;
 336
 337 fail_free_handlers:
 338         TALLOC_FREE(state->sighup_handler);
 339         TALLOC_FREE(state->sigchld_handler);
 340 fail_dereg_printer_drvupgrade:
 341         messaging_deregister(msg_ctx, MSG_PRINTER_DRVUPGRADE, NULL);
 342 fail_dereg_printer_update:
 343         messaging_deregister(msg_ctx, MSG_PRINTER_UPDATE, NULL);
 344 fail_dereg_smb_conf_updated:
 345         messaging_deregister(msg_ctx, MSG_SMB_CONF_UPDATED, state);
 346 fail:
 347         TALLOC_FREE(state);
 348         return NULL;
 349 }
 350
 351 /****************************************************************************
 352 main thread of the background lpq updater
 353 ****************************************************************************/
 354 pid_t start_background_queue(struct tevent_context *ev,
 355                              struct messaging_context *msg_ctx,
 356                              char *logfile)
 357 {
 358         pid_t pid;
 359         int ret;
 360         ssize_t nread;
 361         char **argv = NULL;
 362         int ready_fds[2];
 363
 364         DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
 365
 366         ret = pipe(ready_fds);
 367         if (ret == -1) {
 368                 return -1;
 369         }
 370
 371         argv = str_list_make_empty(talloc_tos());
 372         str_list_add_printf(
 373                 &argv, "%s/samba-bgqd", get_dyn_SAMBA_LIBEXECDIR());
 374         str_list_add_printf(
 375                 &argv, "--ready-signal-fd=%d", ready_fds[1]);
 376         str_list_add_printf(
 377                 &argv, "--parent-watch-fd=%d", 0);
 378         str_list_add_printf(
 379                 &argv, "--debuglevel=%d", debuglevel_get_class(DBGC_RPC_SRV));
 380         if (!is_default_dyn_CONFIGFILE()) {
 381                 str_list_add_printf(
 382                         &argv, "--configfile=%s", get_dyn_CONFIGFILE());
 383         }
 384         if (!is_default_dyn_LOGFILEBASE()) {
 385                 str_list_add_printf(
 386                         &argv, "--log-basename=%s", get_dyn_LOGFILEBASE());
 387         }
 388         str_list_add_printf(&argv, "-F");
 389         if (argv == NULL) {
 390                 goto nomem;
 391         }
 392
 393         ret = posix_spawn(&pid, argv[0], NULL, NULL, argv, environ);
 394         if (ret == -1) {
 395                 goto fail;
 396         }
 397         TALLOC_FREE(argv);
 398
 399         close(ready_fds[1]);
 400
 401         nread = sys_read(ready_fds[0], &pid, sizeof(pid));
 402         close(ready_fds[0]);
 403         if (nread != sizeof(pid)) {
 404                 goto fail;
 405         }
 406
 407         return pid;
 408
 409 nomem:
 410         errno = ENOMEM;
 411 fail:
 412         {
 413                 int err = errno;
 414                 TALLOC_FREE(argv);
 415                 errno = err;
 416         }
 417
 418         return -1;
 419 }
 420
 421
 422 /* Run before the parent forks */
 423 bool printing_subsystem_init(struct tevent_context *ev_ctx,
 424                              struct messaging_context *msg_ctx,
 425                              struct dcesrv_context *dce_ctx)
 426 {
 427         pid_t pid = -1;
 428
 429         pid = start_background_queue(NULL, NULL, NULL);
 430         if (pid == -1) {
 431                 return false;
 432         }
 433         background_lpq_updater_pid = pid;
 434
 435         if (!print_backend_init(msg_ctx)) {
 436                 return false;
 437         }
 438
 439         return true;
 440 }
 441
 442 void send_to_bgqd(struct messaging_context *msg_ctx,
 443                   uint32_t msg_type,
 444                   const uint8_t *buf,
 445                   size_t buflen)
 446 {
 447         pid_t bgqd = pidfile_pid(lp_pid_directory(), "samba-bgqd");
 448
 449         if (bgqd == -1) {
 450                 return;
 451         }
 452         messaging_send_buf(
 453                 msg_ctx, pid_to_procid(bgqd), msg_type, buf, buflen);
 454 }