Changeset 988 for vendor/current/source3/printing

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source3/printing

Files:

• load.c (modified) (4 diffs)
• lpq_parse.c (modified) (2 diffs)
• notify.c (modified) (34 diffs)
• notify.h (modified) (2 diffs)
• nt_printing.c (modified) (47 diffs)
• nt_printing_ads.c (modified) (23 diffs)
• nt_printing_migrate.c (modified) (7 diffs)
• nt_printing_migrate_internal.c (modified) (2 diffs)
• nt_printing_os2.c (modified) (1 diff)
• nt_printing_tdb.c (modified) (15 diffs)
• pcap.c (modified) (9 diffs)
• pcap.h (modified) (3 diffs)
• print_aix.c (modified) (7 diffs)
• print_cups.c (modified) (22 diffs)
• print_generic.c (modified) (9 diffs)
• print_iprint.c (modified) (15 diffs)
• print_standard.c (modified) (3 diffs)
• print_svid.c (modified) (2 diffs)
• printer_list.c (modified) (18 diffs)
• printer_list.h (modified) (1 diff)
• printing.c (modified) (127 diffs)
• printing_db.c (modified) (6 diffs)
• printspoolss.c (modified) (14 diffs)
• queue_process.c (added)
• queue_process.h (added)
• spoolssd.c (modified) (9 diffs)
• tests/vlp.c (modified) (2 diffs)

vendor/current/source3/printing/load.c

@@ -21 +21 @@
 #include "printing/pcap.h"
 #include "printing/load.h"
+#include "lib/param/loadparm.h"
 
 /***************************************************************************
@@ -40 +41 @@
                 return;
 
-        auto_serv = lp_auto_services();
+        auto_serv = lp_auto_services(talloc_tos());
         str = SMB_STRDUP(auto_serv);
         TALLOC_FREE(auto_serv);
@@ -65 +66 @@
                    struct messaging_context *msg_ctx)
 {
-        SMB_ASSERT(pcap_cache_loaded());
+        SMB_ASSERT(pcap_cache_loaded(NULL));
 
         add_auto_printers();
@@ -71 +72 @@
         /* load all printcap printers */
         if (lp_load_printers() && lp_servicenumber(PRINTERS_NAME) >= 0)
-                pcap_printer_fn(lp_add_one_printer, NULL);
+                pcap_printer_read_fn(lp_add_one_printer, NULL);
 }

vendor/current/source3/printing/lpq_parse.c

@@ -802 +802 @@
                 char *p = strrchr_m(tok[6],'/');
                 if (p) {
+                        size_t len = strlen(tok[6])+1;
                         fstrcpy(tmp,p+1);
-                        fstrcpy(tok[6],tmp);
+                        strlcpy(tok[6],tmp, len);
                 }
         }
@@ -1117 +1118 @@
                         handle them so that most severe condition is shown */
                 int i;
-                strlower_m(line);
+                if (!strlower_m(line)) {
+                        return false;
+                }
       
                 switch (status->status) {

vendor/current/source3/printing/notify.c

@@ -36 +36 @@
         struct spoolss_notify_msg *msg;
         struct timeval tv;
-        uint8 *buf;
+        uint8_t *buf;
         size_t buflen;
 } *notify_queue_head = NULL;
@@ -63 +63 @@
 {
         int snum = lp_servicenumber(qname);
-        if (snum == -1 || !lp_print_ok(snum))
+        if (snum == -1 || !lp_printable(snum))
                 return -1;
         return snum;
@@ -84 +84 @@
 {
         struct spoolss_notify_msg *msg = q->msg;
-        uint8 *buf = NULL;
+        uint8_t *buf = NULL;
         size_t buflen = 0, len;
 
@@ -95 +95 @@
 
         len += tdb_pack(buf + len, buflen - len, "ddddddd",
-                        (uint32)q->tv.tv_sec, (uint32)q->tv.tv_usec,
+                        (uint32_t)q->tv.tv_sec, (uint32_t)q->tv.tv_usec,
                         msg->type, msg->field, msg->id, msg->len, msg->flags);
 
@@ -108 +108 @@
 
         if (buflen != len) {
-                buf = (uint8 *)TALLOC_REALLOC(send_ctx, buf, len);
+                buf = (uint8_t *)TALLOC_REALLOC(send_ctx, buf, len);
                 if (!buf)
                         return False;
@@ -195 +195 @@
                                    pid_to_procid(pid_list[i]),
                                    MSG_PRINTER_NOTIFY2 | MSG_FLAG_LOWPRIORITY,
-                                   (uint8 *)buf, offset);
+                                   (uint8_t *)buf, offset);
 
                 if ((timeout != 0) && timeval_expired(&end_time)) {
@@ -255 +255 @@
         
         if ( from->len ) {
-                to->notify.data = (char *)TALLOC_MEMDUP(send_ctx, from->notify.data, from->len );
+                to->notify.data = (char *)talloc_memdup(send_ctx, from->notify.data, from->len );
                 if ( !to->notify.data ) {
-                        DEBUG(0,("copy_notify2_msg: TALLOC_MEMDUP() of size [%d] failed!\n", from->len ));
+                        DEBUG(0,("copy_notify2_msg: talloc_memdup() of size [%d] failed!\n", from->len ));
                         return False;
                 }
@@ -306 +306 @@
         /* Store the message on the pending queue. */
 
-        pnqueue = TALLOC_P(send_ctx, struct notify_queue);
+        pnqueue = talloc(send_ctx, struct notify_queue);
         if (!pnqueue) {
                 DEBUG(0,("send_spoolss_notify2_msg: Out of memory.\n"));
@@ -314 +314 @@
         /* allocate a new msg structure and copy the fields */
         
-        if ( !(pnqueue->msg = TALLOC_P(send_ctx, SPOOLSS_NOTIFY_MSG)) ) {
+        if ( !(pnqueue->msg = talloc(send_ctx, SPOOLSS_NOTIFY_MSG)) ) {
                 DEBUG(0,("send_spoolss_notify2_msg: talloc() of size [%lu] failed!\n", 
                         (unsigned long)sizeof(SPOOLSS_NOTIFY_MSG)));
@@ -332 +332 @@
          */
 
-        DLIST_ADD_END(notify_queue_head, pnqueue, struct notify_queue *);
+        DLIST_ADD_END(notify_queue_head, pnqueue);
         num_messages++;
 
@@ -346 +346 @@
 static void send_notify_field_values(struct tevent_context *ev,
                                      struct messaging_context *msg_ctx,
-                                     const char *sharename, uint32 type,
-                                     uint32 field, uint32 id, uint32 value1, 
-                                     uint32 value2, uint32 flags)
+                                     const char *sharename, uint32_t type,
+                                     uint32_t field, uint32_t id, uint32_t value1,
+                                     uint32_t value2, uint32_t flags)
 {
         struct spoolss_notify_msg *msg;
@@ -358 +358 @@
                 return;
 
-        msg = TALLOC_P(send_ctx, struct spoolss_notify_msg);
+        msg = talloc_zero(send_ctx, struct spoolss_notify_msg);
         if (!msg)
                 return;
-
-        ZERO_STRUCTP(msg);
 
         fstrcpy(msg->printer, sharename);
@@ -377 +375 @@
 static void send_notify_field_buffer(struct tevent_context *ev,
                                      struct messaging_context *msg_ctx,
-                                     const char *sharename, uint32 type,
-                                     uint32 field, uint32 id, uint32 len,
+                                     const char *sharename, uint32_t type,
+                                     uint32_t field, uint32_t id, uint32_t len,
                                      const char *buffer)
 {
@@ -389 +387 @@
                 return;
 
-        msg = TALLOC_P(send_ctx, struct spoolss_notify_msg);
+        msg = talloc_zero(send_ctx, struct spoolss_notify_msg);
         if (!msg)
                 return;
-
-        ZERO_STRUCTP(msg);
 
         fstrcpy(msg->printer, sharename);
@@ -400 +396 @@
         msg->id = id;
         msg->len = len;
-        msg->notify.data = CONST_DISCARD(char *,buffer);
+        msg->notify.data = discard_const_p(char, buffer);
 
         send_spoolss_notify2_msg(ev, msg_ctx, msg);
@@ -409 +405 @@
 void notify_printer_status_byname(struct tevent_context *ev,
                                   struct messaging_context *msg_ctx,
-                                  const char *sharename, uint32 status)
+                                  const char *sharename, uint32_t status)
 {
         /* Printer status stored in value1 */
@@ -422 +418 @@
 void notify_printer_status(struct tevent_context *ev,
                            struct messaging_context *msg_ctx,
-                           int snum, uint32 status)
-{
-        const char *sharename = lp_servicename(snum);
+                           int snum, uint32_t status)
+{
+        const char *sharename = lp_servicename(talloc_tos(), snum);
 
         if (sharename)
@@ -432 +428 @@
 void notify_job_status_byname(struct tevent_context *ev,
                               struct messaging_context *msg_ctx,
-                              const char *sharename, uint32 jobid,
-                              uint32 status,
-                              uint32 flags)
+                              const char *sharename, uint32_t jobid,
+                              uint32_t status,
+                              uint32_t flags)
 {
         /* Job id stored in id field, status in value1 */
@@ -446 +442 @@
 void notify_job_status(struct tevent_context *ev,
                        struct messaging_context *msg_ctx,
-                       const char *sharename, uint32 jobid, uint32 status)
+                       const char *sharename, uint32_t jobid, uint32_t status)
 {
         notify_job_status_byname(ev, msg_ctx, sharename, jobid, status, 0);
@@ -453 +449 @@
 void notify_job_total_bytes(struct tevent_context *ev,
                             struct messaging_context *msg_ctx,
-                            const char *sharename, uint32 jobid,
-                            uint32 size)
+                            const char *sharename, uint32_t jobid,
+                            uint32_t size)
 {
         /* Job id stored in id field, status in value1 */
@@ -466 +462 @@
 void notify_job_total_pages(struct tevent_context *ev,
                             struct messaging_context *msg_ctx,
-                            const char *sharename, uint32 jobid,
-                            uint32 pages)
+                            const char *sharename, uint32_t jobid,
+                            uint32_t pages)
 {
         /* Job id stored in id field, status in value1 */
@@ -479 +475 @@
 void notify_job_username(struct tevent_context *ev,
                          struct messaging_context *msg_ctx,
-                         const char *sharename, uint32 jobid, char *name)
+                         const char *sharename, uint32_t jobid, char *name)
 {
         send_notify_field_buffer(
@@ -489 +485 @@
 void notify_job_name(struct tevent_context *ev,
                      struct messaging_context *msg_ctx,
-                     const char *sharename, uint32 jobid, char *name)
+                     const char *sharename, uint32_t jobid, char *name)
 {
         send_notify_field_buffer(
@@ -499 +495 @@
 void notify_job_submitted(struct tevent_context *ev,
                           struct messaging_context *msg_ctx,
-                          const char *sharename, uint32 jobid,
+                          const char *sharename, uint32_t jobid,
                           time_t submitted)
 {
@@ -512 +508 @@
                            int snum, const char *driver_name)
 {
-        const char *sharename = lp_servicename(snum);
+        const char *sharename = lp_servicename(talloc_tos(), snum);
 
         send_notify_field_buffer(
@@ -524 +520 @@
                             int snum, const char *comment)
 {
-        const char *sharename = lp_servicename(snum);
+        const char *sharename = lp_servicename(talloc_tos(), snum);
 
         send_notify_field_buffer(
@@ -536 +532 @@
                               int snum, const char *share_name)
 {
-        const char *sharename = lp_servicename(snum);
+        const char *sharename = lp_servicename(talloc_tos(), snum);
 
         send_notify_field_buffer(
@@ -548 +544 @@
                                 int snum, const char *printername)
 {
-        const char *sharename = lp_servicename(snum);
+        const char *sharename = lp_servicename(talloc_tos(), snum);
 
         send_notify_field_buffer(
@@ -560 +556 @@
                          int snum, const char *port_name)
 {
-        const char *sharename = lp_servicename(snum);
+        const char *sharename = lp_servicename(talloc_tos(), snum);
 
         send_notify_field_buffer(
@@ -572 +568 @@
                              int snum, const char *location)
 {
-        const char *sharename = lp_servicename(snum);
+        const char *sharename = lp_servicename(talloc_tos(), snum);
 
         send_notify_field_buffer(
@@ -584 +580 @@
                             int snum, const char *sepfile)
 {
-        const char *sharename = lp_servicename(snum);
+        const char *sharename = lp_servicename(talloc_tos(), snum);
 
         send_notify_field_buffer(
@@ -595 +591 @@
 void notify_printer_byname(struct tevent_context *ev,
                            struct messaging_context *msg_ctx,
-                           const char *printername, uint32 change,
+                           const char *printername, uint32_t change,
                            const char *value)
 {
@@ -633 +629 @@
         tdb = pdb->tdb;
 
-        if (tdb_read_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
+        if (tdb_read_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) != 0) {
                 DEBUG(0,("print_notify_pid_list: Failed to lock printer %s database\n",
                                         printername));
@@ -651 +647 @@
 
         if (num_pids) {
-                if ((pid_list = TALLOC_ARRAY(mem_ctx, pid_t, num_pids)) == NULL) {
+                if ((pid_list = talloc_array(mem_ctx, pid_t, num_pids)) == NULL) {
                         ret = False;
                         goto done;

vendor/current/source3/printing/notify.h

@@ -30 +30 @@
 void notify_printer_status_byname(struct tevent_context *ev,
                                   struct messaging_context *msg_ctx,
-                                  const char *sharename, uint32 status);
+                                  const char *sharename, uint32_t status);
 void notify_printer_status(struct tevent_context *ev,
                            struct messaging_context *msg_ctx,
-                           int snum, uint32 status);
+                           int snum, uint32_t status);
 void notify_job_status_byname(struct tevent_context *ev,
                               struct messaging_context *msg_ctx,
-                              const char *sharename, uint32 jobid,
-                              uint32 status,
-                              uint32 flags);
+                              const char *sharename, uint32_t jobid,
+                              uint32_t status,
+                              uint32_t flags);
 void notify_job_status(struct tevent_context *ev,
                        struct messaging_context *msg_ctx,
-                       const char *sharename, uint32 jobid, uint32 status);
+                       const char *sharename, uint32_t jobid, uint32_t status);
 void notify_job_total_bytes(struct tevent_context *ev,
                             struct messaging_context *msg_ctx,
-                            const char *sharename, uint32 jobid,
-                            uint32 size);
+                            const char *sharename, uint32_t jobid,
+                            uint32_t size);
 void notify_job_total_pages(struct tevent_context *ev,
                             struct messaging_context *msg_ctx,
-                            const char *sharename, uint32 jobid,
-                            uint32 pages);
+                            const char *sharename, uint32_t jobid,
+                            uint32_t pages);
 void notify_job_username(struct tevent_context *ev,
                          struct messaging_context *msg_ctx,
-                         const char *sharename, uint32 jobid, char *name);
+                         const char *sharename, uint32_t jobid, char *name);
 void notify_job_name(struct tevent_context *ev,
                      struct messaging_context *msg_ctx,
-                     const char *sharename, uint32 jobid, char *name);
+                     const char *sharename, uint32_t jobid, char *name);
 void notify_job_submitted(struct tevent_context *ev,
                           struct messaging_context *msg_ctx,
-                          const char *sharename, uint32 jobid,
+                          const char *sharename, uint32_t jobid,
                           time_t submitted);
 void notify_printer_driver(struct tevent_context *ev,
@@ -80 +80 @@
 void notify_printer_byname(struct tevent_context *ev,
                            struct messaging_context *msg_ctx,
-                           const char *printername, uint32 change,
+                           const char *printername, uint32_t change,
                            const char *value);
 void notify_printer_sepfile(struct tevent_context *ev,

vendor/current/source3/printing/nt_printing.c

@@ -30 +30 @@
 #include "passdb/machine_sid.h"
 #include "smbd/smbd.h"
+#include "smbd/globals.h"
 #include "auth.h"
 #include "messages.h"
@@ -74 +75 @@
 };
 
+static bool print_driver_directories_init(void)
+{
+        int service, i;
+        char *driver_path;
+        bool ok;
+        TALLOC_CTX *mem_ctx = talloc_stackframe();
+
+        service = lp_servicenumber("print$");
+        if (service < 0) {
+                /* We don't have a print$ share */
+                DEBUG(5, ("No print$ share has been configured.\n"));
+                talloc_free(mem_ctx);
+                return true;
+        }
+
+        driver_path = lp_path(mem_ctx, service);
+        if (driver_path == NULL) {
+                talloc_free(mem_ctx);
+                return false;
+        }
+
+        ok = directory_create_or_exist(driver_path, 0755);
+        if (!ok) {
+                DEBUG(1, ("Failed to create printer driver directory %s\n",
+                          driver_path));
+                talloc_free(mem_ctx);
+                return false;
+        }
+
+        for (i = 0; archi_table[i].long_archi != NULL; i++) {
+                const char *arch_path;
+
+                arch_path = talloc_asprintf(mem_ctx,
+                                            "%s/%s",
+                                            driver_path,
+                                            archi_table[i].short_archi);
+                if (arch_path == NULL) {
+                        talloc_free(mem_ctx);
+                        return false;
+                }
+
+                ok = directory_create_or_exist(arch_path, 0755);
+                if (!ok) {
+                        DEBUG(1, ("Failed to create printer driver "
+                                  "architecture directory %s\n",
+                                  arch_path));
+                        talloc_free(mem_ctx);
+                        return false;
+                }
+        }
+
+        talloc_free(mem_ctx);
+        return true;
+}
+
+/****************************************************************************
+ Forward a MSG_PRINTER_DRVUPGRADE message from another smbd to the
+ background lpq updater.
+****************************************************************************/
+
+static void forward_drv_upgrade_printer_msg(struct messaging_context *msg,
+                                void *private_data,
+                                uint32_t msg_type,
+                                struct server_id server_id,
+                                DATA_BLOB *data)
+{
+        extern pid_t background_lpq_updater_pid;
+
+        if (background_lpq_updater_pid == -1) {
+                DEBUG(3,("no background lpq queue updater\n"));
+                return;
+        }
+
+        messaging_send_buf(msg,
+                        pid_to_procid(background_lpq_updater_pid),
+                        MSG_PRINTER_DRVUPGRADE,
+                        data->data,
+                        data->length);
+}
+
 /****************************************************************************
  Open the NT printing tdbs. Done once before fork().
@@ -82 +163 @@
         WERROR win_rc;
 
+        if (!print_driver_directories_init()) {
+                return false;
+        }
+
         if (!nt_printing_tdb_upgrade()) {
                 return false;
@@ -88 +173 @@
         /*
          * register callback to handle updating printers as new
-         * drivers are installed
+         * drivers are installed. Forwards to background lpq updater.
          */
         messaging_register(msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE,
-                           do_drv_upgrade_printer);
+                        forward_drv_upgrade_printer_msg);
 
         /* of course, none of the message callbacks matter if you don't
@@ -149 +234 @@
                 i++;
         } while ( (archi_table[i].long_archi!=NULL ) &&
-                  StrCaseCmp(long_archi, archi_table[i].long_archi) );
+                  strcasecmp_m(long_archi, archi_table[i].long_archi) );
 
         if (archi_table[i].long_archi==NULL) {
@@ -173 +258 @@
 ****************************************************************************/
 
-static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32 *minor)
+static int get_file_version(files_struct *fsp, char *fname,uint32_t *major, uint32_t *minor)
 {
         int     i;
@@ -199 +284 @@
 
         /* Skip OEM header (if any) and the DOS stub to start of Windows header */
-        if (SMB_VFS_LSEEK(fsp, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
+        if (SMB_VFS_LSEEK(fsp, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (off_t)-1) {
                 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
                                 fname, errno));
@@ -222 +307 @@
                 if (SMB_VFS_LSEEK(fsp,
                                 SVAL(buf,PE_HEADER_OPTIONAL_HEADER_SIZE)-(NE_HEADER_SIZE-PE_HEADER_SIZE),
-                                SEEK_CUR) == (SMB_OFF_T)-1) {
+                                SEEK_CUR) == (off_t)-1) {
                         DEBUG(3,("get_file_version: File [%s] Windows optional header too short, errno = %d\n",
                                 fname, errno));
@@ -266 +351 @@
 
                                 /* Seek to the start of the .rsrc section info */
-                                if (SMB_VFS_LSEEK(fsp, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
+                                if (SMB_VFS_LSEEK(fsp, section_pos, SEEK_SET) == (off_t)-1) {
                                         DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
                                                         fname, errno));
@@ -411 +496 @@
         bool use_version = true;
 
-        uint32 new_major;
-        uint32 new_minor;
+        uint32_t new_major;
+        uint32_t new_minor;
         time_t new_create_time;
 
-        uint32 old_major;
-        uint32 old_minor;
+        uint32_t old_major;
+        uint32_t old_minor;
         time_t old_create_time;
 
@@ -447 +532 @@
                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
+                NULL,                                   /* lease */
                 0,                                      /* allocation_size */
                 0,                                      /* private_flags */
@@ -452 +538 @@
                 NULL,                                   /* ea_list */
                 &fsp,                                   /* result */
-                NULL);                                  /* pinfo */
+                NULL,                                   /* pinfo */
+                NULL, NULL);                            /* create context */
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -500 +587 @@
                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
+                NULL,                                   /* lease */
                 0,                                      /* allocation_size */
                 0,                                      /* private_flags */
@@ -505 +593 @@
                 NULL,                                   /* ea_list */
                 &fsp,                                   /* result */
-                NULL);                                  /* pinfo */
+                NULL,                                   /* pinfo */
+                NULL, NULL);                            /* create context */
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -575 +664 @@
 Determine the correct cVersion associated with an architecture and driver
 ****************************************************************************/
-static uint32 get_correct_cversion(struct auth_serversupplied_info *session_info,
+static uint32_t get_correct_cversion(struct auth_session_info *session_info,
                                    const char *architecture,
                                    const char *driverpath_in,
@@ -616 +705 @@
         }
 
-        nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
-                                       lp_pathname(printdollar_snum),
-                                       session_info, &oldcwd);
+        nt_status = create_conn_struct_cwd(talloc_tos(),
+                                           server_event_context(),
+                                           server_messaging_context(),
+                                           &conn,
+                                           printdollar_snum,
+                                           lp_path(talloc_tos(), printdollar_snum),
+                                           session_info, &oldcwd);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0,("get_correct_cversion: create_conn_struct "
@@ -674 +767 @@
                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
+                NULL,                                   /* lease */
                 0,                                      /* private_flags */
                 0,                                      /* allocation_size */
@@ -679 +773 @@
                 NULL,                                   /* ea_list */
                 &fsp,                                   /* result */
-                NULL);                                  /* pinfo */
+                NULL,                                   /* pinfo */
+                NULL, NULL);                            /* create context */
 
         if (!NT_STATUS_IS_OK(nt_status)) {
@@ -687 +782 @@
                 goto error_exit;
         } else {
-                uint32 major;
-                uint32 minor;
+                uint32_t major;
+                uint32_t minor;
                 int    ret;
 
@@ -745 +840 @@
                 conn_free(conn);
         }
-        if (!NT_STATUS_IS_OK(*perr)) {
+        if (!W_ERROR_IS_OK(*perr)) {
                 cversion = -1;
         }
@@ -763 +858 @@
 
 static WERROR clean_up_driver_struct_level(TALLOC_CTX *mem_ctx,
-                                           struct auth_serversupplied_info *session_info,
+                                           struct auth_session_info *session_info,
                                            const char *architecture,
                                            const char **driver_path,
@@ -836 +931 @@
 
 WERROR clean_up_driver_struct(TALLOC_CTX *mem_ctx,
-                              struct auth_serversupplied_info *session_info,
+                              struct auth_session_info *session_info,
                               struct spoolss_AddDriverInfoCtr *r)
 {
@@ -921 +1016 @@
 
                 /* Setup a synthetic smb_filename struct */
-                smb_fname_new = TALLOC_ZERO_P(mem_ctx, struct smb_filename);
+                smb_fname_new = talloc_zero(mem_ctx, struct smb_filename);
                 if (!smb_fname_new) {
                         ret = WERR_NOMEM;
@@ -955 +1050 @@
 }
 
-WERROR move_driver_to_download_area(struct auth_serversupplied_info *session_info,
+WERROR move_driver_to_download_area(struct auth_session_info *session_info,
                                     struct spoolss_AddDriverInfoCtr *r)
 {
@@ -999 +1094 @@
         }
 
-        nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
-                                       lp_pathname(printdollar_snum),
-                                       session_info, &oldcwd);
+        nt_status = create_conn_struct_cwd(talloc_tos(),
+                                           server_event_context(),
+                                           server_messaging_context(),
+                                           &conn,
+                                           printdollar_snum,
+                                           lp_path(talloc_tos(), printdollar_snum),
+                                           session_info, &oldcwd);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0,("move_driver_to_download_area: create_conn_struct "
@@ -1175 +1274 @@
 
 bool printer_driver_in_use(TALLOC_CTX *mem_ctx,
-                           const struct auth_serversupplied_info *session_info,
-                           struct messaging_context *msg_ctx,
-                           const struct spoolss_DriverInfo8 *r)
+                           struct dcerpc_binding_handle *b,
+                           const struct spoolss_DriverInfo8 *r)
 {
         int snum;
@@ -1184 +1282 @@
         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
         WERROR result;
-        struct dcerpc_binding_handle *b = NULL;
 
         if (!r) {
@@ -1195 +1292 @@
 
         for (snum=0; snum<n_services && !in_use; snum++) {
-                if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
+                if (!lp_snum_ok(snum) || !lp_printable(snum)) {
                         continue;
                 }
 
-                if (b == NULL) {
-                        result = winreg_printer_binding_handle(mem_ctx,
-                                                               session_info,
-                                                               msg_ctx,
-                                                               &b);
-                        if (!W_ERROR_IS_OK(result)) {
-                                return false;
-                        }
-                }
-
                 result = winreg_get_printer(mem_ctx, b,
-                                            lp_servicename(snum),
+                                            lp_servicename(talloc_tos(), snum),
                                             &pinfo2);
                 if (!W_ERROR_IS_OK(result)) {
@@ -1226 +1313 @@
 
         if ( in_use ) {
-                struct spoolss_DriverInfo8 *driver;
+                struct spoolss_DriverInfo8 *driver = NULL;
                 WERROR werr;
 
@@ -1414 +1501 @@
 
 bool printer_driver_files_in_use(TALLOC_CTX *mem_ctx,
-                                 const struct auth_serversupplied_info *session_info,
-                                 struct messaging_context *msg_ctx,
+                                 struct dcerpc_binding_handle *b,
                                  struct spoolss_DriverInfo8 *info)
 {
         int                             i;
-        uint32                          version;
+        uint32_t                                version;
         struct spoolss_DriverInfo8      *driver;
         bool in_use = false;
@@ -1425 +1511 @@
         const char **drivers;
         WERROR result;
-        struct dcerpc_binding_handle *b;
 
         if ( !info )
@@ -1437 +1522 @@
 
         /* get the list of drivers */
-
-        result = winreg_printer_binding_handle(mem_ctx,
-                                               session_info,
-                                               msg_ctx,
-                                               &b);
-        if (!W_ERROR_IS_OK(result)) {
-                return false;
-        }
 
         result = winreg_get_driver_list(mem_ctx, b,
@@ -1509 +1586 @@
         }
 
-        status = create_synthetic_smb_fname(tmp_ctx, print_dlr_path,
-                                            NULL, NULL, &smb_fname);
-        if (!NT_STATUS_IS_OK(status)) {
+        smb_fname = synthetic_smb_fname(tmp_ctx, print_dlr_path, NULL, NULL);
+        if (smb_fname == NULL) {
                 goto err_out;
         }
@@ -1527 +1603 @@
 ****************************************************************************/
 
-bool delete_driver_files(const struct auth_serversupplied_info *session_info,
+bool delete_driver_files(const struct auth_session_info *session_info,
                          const struct spoolss_DriverInfo8 *r)
 {
@@ -1553 +1629 @@
         }
 
-        nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
-                                       lp_pathname(printdollar_snum),
-                                       session_info, &oldcwd);
+        nt_status = create_conn_struct_cwd(talloc_tos(),
+                                           server_event_context(),
+                                           server_messaging_context(),
+                                           &conn,
+                                           printdollar_snum,
+                                           lp_path(talloc_tos(), printdollar_snum),
+                                           session_info, &oldcwd);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0,("delete_driver_files: create_conn_struct "
@@ -1637 +1717 @@
         3: can't allocate memory
         4: can't free memory
-        5: non existant struct
+        5: non existent struct
 */
 
@@ -1715 +1795 @@
 
  ****************************************************************************/
-bool print_access_check(const struct auth_serversupplied_info *session_info,
-                        struct messaging_context *msg_ctx, int snum,
-                        int access_type)
+WERROR print_access_check(const struct auth_session_info *session_info,
+                          struct messaging_context *msg_ctx, int snum,
+                          int access_type)
 {
         struct spoolss_security_descriptor *secdesc = NULL;
-        uint32 access_granted;
+        uint32_t access_granted;
         size_t sd_size;
         NTSTATUS status;
@@ -1731 +1811 @@
         /* Always allow root or SE_PRINT_OPERATROR to do anything */
 
-        if (session_info->utok.uid == sec_initial_uid()
-            || security_token_has_privilege(session_info->security_token, SEC_PRIV_PRINT_OPERATOR)) {
-                return True;
+        if ((session_info->unix_token->uid == sec_initial_uid())
+            || security_token_has_privilege(session_info->security_token,
+                                            SEC_PRIV_PRINT_OPERATOR)) {
+                return WERR_OK;
         }
 
         /* Get printer name */
 
-        pname = lp_printername(snum);
+        pname = lp_printername(talloc_tos(), snum);
 
         if (!pname || !*pname) {
-                errno = EACCES;
-                return False;
+                return WERR_ACCESS_DENIED;
         }
 
@@ -1748 +1828 @@
 
         if(!(mem_ctx = talloc_init("print_access_check"))) {
-                errno = ENOMEM;
-                return False;
+                return WERR_NOMEM;
         }
 
@@ -1759 +1838 @@
         if (!W_ERROR_IS_OK(result)) {
                 talloc_destroy(mem_ctx);
-                errno = ENOMEM;
-                return False;
+                return WERR_NOMEM;
         }
 
@@ -1778 +1856 @@
                 if (!NT_STATUS_IS_OK(status)) {
                         talloc_destroy(mem_ctx);
-                        errno = map_errno_from_nt_status(status);
-                        return False;
+                        return ntstatus_to_werror(status);
                 }
 
@@ -1793 +1870 @@
         DEBUG(4, ("access check was %s\n", NT_STATUS_IS_OK(status) ? "SUCCESS" : "FAILURE"));
 
-        /* see if we need to try the printer admin list */
-
-        if (!NT_STATUS_IS_OK(status) &&
-            (token_contains_name_in_list(uidtoname(session_info->utok.uid),
-                                         session_info->info3->base.domain.string,
-                                         NULL, session_info->security_token,
-                                         lp_printer_admin(snum)))) {
-                talloc_destroy(mem_ctx);
-                return True;
-        }
-
         talloc_destroy(mem_ctx);
 
-        if (!NT_STATUS_IS_OK(status)) {
-                errno = EACCES;
-        }
-
-        return NT_STATUS_IS_OK(status);
+        return ntstatus_to_werror(status);
 }
 
@@ -1817 +1879 @@
 *****************************************************************************/
 
-bool print_time_access_check(const struct auth_serversupplied_info *session_info,
+bool print_time_access_check(const struct auth_session_info *session_info,
                              struct messaging_context *msg_ctx,
                              const char *servicename)
@@ -1826 +1888 @@
         time_t now = time(NULL);
         struct tm *t;
-        uint32 mins;
+        uint32_t mins;
 
         result = winreg_get_printer_internal(NULL, session_info, msg_ctx,
@@ -1839 +1901 @@
 
         t = gmtime(&now);
-        mins = (uint32)t->tm_hour*60 + (uint32)t->tm_min;
+        mins = (uint32_t)t->tm_hour*60 + (uint32_t)t->tm_min;
 
         if (mins >= pinfo2->starttime && mins <= pinfo2->untiltime) {
@@ -1855 +1917 @@
 
 void nt_printer_remove(TALLOC_CTX *mem_ctx,
-                        const struct auth_serversupplied_info *session_info,
+                        const struct auth_session_info *session_info,
                         struct messaging_context *msg_ctx,
                         const char *printer)
@@ -1865 +1927 @@
         if (!W_ERROR_IS_OK(result)) {
                 DEBUG(0, ("nt_printer_remove: failed to remove printer %s: "
-                          "%s\n", printer, win_errstr(result)));
+                "%s\n", printer, win_errstr(result)));
         }
 }
 
 void nt_printer_add(TALLOC_CTX *mem_ctx,
-                    const struct auth_serversupplied_info *session_info,
+                    const struct auth_session_info *session_info,
                     struct messaging_context *msg_ctx,
                     const char *printer)

vendor/current/source3/printing/nt_printing_ads.c

@@ -36 +36 @@
  ****************************************************************/
 
-static void store_printer_guid(struct messaging_context *msg_ctx,
-                               const char *printer, struct GUID guid)
+WERROR nt_printer_guid_store(struct messaging_context *msg_ctx,
+                             const char *printer, struct GUID guid)
 {
         TALLOC_CTX *tmp_ctx;
-        struct auth_serversupplied_info *session_info = NULL;
+        const struct auth_session_info *session_info;
         const char *guid_str;
         DATA_BLOB blob;
-        NTSTATUS status;
         WERROR result;
 
         tmp_ctx = talloc_new(NULL);
         if (!tmp_ctx) {
-                DEBUG(0, ("store_printer_guid: Out of memory?!\n"));
-                return;
-        }
-
-        status = make_session_info_system(tmp_ctx, &session_info);
-        if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0, ("store_printer_guid: "
-                          "Could not create system session_info\n"));
+                DEBUG(0, ("Out of memory?!\n"));
+                return WERR_NOMEM;
+        }
+
+        session_info = get_session_info_system();
+        if (session_info == NULL) {
+                DEBUG(0, ("Could not get system session_info\n"));
+                result = WERR_NOMEM;
                 goto done;
         }
@@ -61 +60 @@
         guid_str = GUID_string(tmp_ctx, &guid);
         if (!guid_str) {
-                DEBUG(0, ("store_printer_guid: Out of memory?!\n"));
+                DEBUG(0, ("Out of memory?!\n"));
+                result = WERR_NOMEM;
                 goto done;
         }
@@ -69 +69 @@
 
         if (!push_reg_sz(tmp_ctx, &blob, guid_str)) {
-                DEBUG(0, ("store_printer_guid: "
-                          "Could not marshall string %s for objectGUID\n",
+                DEBUG(0, ("Could not marshall string %s for objectGUID\n",
                           guid_str));
+                result = WERR_NOMEM;
                 goto done;
         }
@@ -80 +80 @@
                                            REG_SZ, blob.data, blob.length);
         if (!W_ERROR_IS_OK(result)) {
-                DEBUG(0, ("store_printer_guid: "
-                          "Failed to store GUID for printer %s\n", printer));
-        }
-
+                DEBUG(0, ("Failed to store GUID for printer %s\n", printer));
+                goto done;
+        }
+
+        result = WERR_OK;
 done:
         talloc_free(tmp_ctx);
+
+        return result;
+}
+
+static WERROR nt_printer_dn_lookup(TALLOC_CTX *mem_ctx,
+                                   ADS_STRUCT *ads,
+                                   const char *printer,
+                                   char **pprinter_dn)
+{
+        char *printer_dn = NULL;
+        char *srv_dn = NULL;
+        char *srv_cn_0 = NULL;
+        char *srv_cn_escaped = NULL;
+        char *sharename_escaped = NULL;
+        char *srv_dn_utf8 = NULL;
+        char **srv_cn_utf8 = NULL;
+        size_t converted_size;
+        ADS_STATUS ads_status;
+        LDAPMessage *res;
+        WERROR result;
+        bool ok;
+
+        ads_status = ads_find_machine_acct(ads, &res, lp_netbios_name());
+        if (!ADS_ERR_OK(ads_status)) {
+                DEBUG(2, ("Failed to find machine account for %s\n",
+                          lp_netbios_name()));
+                result = WERR_NOT_FOUND;
+                goto err_out;
+        }
+
+        /*
+         * We use ldap_get_dn here as we need the answer in utf8 to call
+         * ldap_explode_dn(). JRA.
+         */
+        srv_dn_utf8 = ldap_get_dn((LDAP *)ads->ldap.ld, (LDAPMessage *)res);
+        ads_msgfree(ads, res);
+        if (srv_dn_utf8 == NULL) {
+                result = WERR_SERVER_UNAVAILABLE;
+                goto err_out;
+        }
+
+        srv_cn_utf8 = ldap_explode_dn(srv_dn_utf8, 1);
+        if (srv_cn_utf8 == NULL) {
+                ldap_memfree(srv_dn_utf8);
+                result = WERR_SERVER_UNAVAILABLE;
+                goto err_out;
+        }
+
+        /* Now convert to CH_UNIX. */
+        ok = pull_utf8_talloc(mem_ctx, &srv_dn, srv_dn_utf8, &converted_size);
+        ldap_memfree(srv_dn_utf8);
+        if (!ok) {
+                ldap_memfree(srv_cn_utf8);
+                result = WERR_SERVER_UNAVAILABLE;
+                goto err_out;
+        }
+
+        ok = pull_utf8_talloc(mem_ctx, &srv_cn_0, srv_cn_utf8[0], &converted_size);
+        ldap_memfree(srv_cn_utf8);
+        if (!ok) {
+                result = WERR_SERVER_UNAVAILABLE;
+                goto err_out;
+        }
+
+        srv_cn_escaped = escape_rdn_val_string_alloc(srv_cn_0);
+        if (srv_cn_escaped == NULL) {
+                result = WERR_SERVER_UNAVAILABLE;
+                goto err_out;
+        }
+
+        sharename_escaped = escape_rdn_val_string_alloc(printer);
+        if (sharename_escaped == NULL) {
+                result = WERR_SERVER_UNAVAILABLE;
+                goto err_out;
+        }
+
+        printer_dn = talloc_asprintf(mem_ctx,
+                                     "cn=%s-%s,%s",
+                                     srv_cn_escaped,
+                                     sharename_escaped,
+                                     srv_dn);
+        if (printer_dn == NULL) {
+                result = WERR_NOMEM;
+                goto err_out;
+        }
+
+        *pprinter_dn = printer_dn;
+
+        result = WERR_OK;
+err_out:
+        SAFE_FREE(sharename_escaped);
+        SAFE_FREE(srv_cn_escaped);
+        TALLOC_FREE(srv_cn_0);
+        TALLOC_FREE(srv_dn);
+        return result;
+}
+
+static WERROR nt_printer_guid_retrieve_internal(ADS_STRUCT *ads,
+                                                const char *printer_dn,
+                                                struct GUID *pguid)
+{
+        ADS_STATUS ads_status;
+        LDAPMessage *res;
+        const char *attrs[] = {"objectGUID", NULL};
+        struct GUID guid;
+        bool ok;
+
+        ads_status = ads_search_dn(ads, &res, printer_dn, attrs);
+        if (!ADS_ERR_OK(ads_status)) {
+                DEBUG(2, ("Failed to retrieve GUID from DC - %s\n",
+                          ads_errstr(ads_status)));
+                return WERR_BADFILE;
+        }
+
+        ZERO_STRUCT(guid);
+        ok = ads_pull_guid(ads, res, &guid);
+        ads_msgfree(ads, res);
+        if (!ok) {
+                return WERR_NOMEM;
+        }
+
+        *pguid = guid;
+
+        return WERR_OK;
+}
+
+WERROR nt_printer_guid_retrieve(TALLOC_CTX *mem_ctx, const char *printer,
+                                struct GUID *pguid)
+{
+        ADS_STRUCT *ads = NULL;
+        char *old_krb5ccname = NULL;
+        char *printer_dn;
+        WERROR result;
+        ADS_STATUS ads_status;
+        TALLOC_CTX *tmp_ctx;
+
+        tmp_ctx = talloc_new(mem_ctx);
+        if (tmp_ctx == NULL) {
+                return WERR_NOMEM;
+        }
+
+        ads = ads_init(lp_realm(), lp_workgroup(), NULL);
+        if (ads == NULL) {
+                result = WERR_SERVER_UNAVAILABLE;
+                goto out;
+        }
+
+        old_krb5ccname = getenv(KRB5_ENV_CCNAME);
+        setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
+        SAFE_FREE(ads->auth.password);
+        ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
+                                                            NULL, NULL);
+
+        ads_status = ads_connect(ads);
+        if (!ADS_ERR_OK(ads_status)) {
+                DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_status)));
+                result = WERR_ACCESS_DENIED;
+                goto out;
+        }
+
+        result = nt_printer_dn_lookup(tmp_ctx, ads, printer, &printer_dn);
+        if (!W_ERROR_IS_OK(result)) {
+                goto out;
+        }
+
+        result = nt_printer_guid_retrieve_internal(ads, printer_dn, pguid);
+out:
+        TALLOC_FREE(tmp_ctx);
+        ads_destroy(&ads);
+        ads_kdestroy("MEMORY:prtpub_cache");
+        unsetenv(KRB5_ENV_CCNAME);
+        if (old_krb5ccname != NULL) {
+                setenv(KRB5_ENV_CCNAME, old_krb5ccname, 0);
+        }
+
+        return result;
 }
 
 WERROR nt_printer_guid_get(TALLOC_CTX *mem_ctx,
-                           const struct auth_serversupplied_info *session_info,
+                           const struct auth_session_info *session_info,
                            struct messaging_context *msg_ctx,
                            const char *printer, struct GUID *guid)
@@ -169 +346 @@
 
         ads_mod_str(ctx, mods, SPOOL_REG_PRINTERNAME, info2->sharename);
-        ads_mod_str(ctx, mods, SPOOL_REG_SHORTSERVERNAME, global_myname());
+        ads_mod_str(ctx, mods, SPOOL_REG_SHORTSERVERNAME, lp_netbios_name());
         ads_mod_str(ctx, mods, SPOOL_REG_SERVERNAME, get_mydnsfullname());
 
@@ -247 +424 @@
 {
         ADS_STATUS ads_rc;
-        LDAPMessage *res;
-        char *prt_dn = NULL, *srv_dn, *srv_cn_0, *srv_cn_escaped, *sharename_escaped;
-        char *srv_dn_utf8, **srv_cn_utf8;
         TALLOC_CTX *ctx;
         ADS_MODLIST mods;
-        const char *attrs[] = {"objectGUID", NULL};
         struct GUID guid;
         WERROR win_rc = WERR_OK;
-        size_t converted_size;
         const char *printer = pinfo2->sharename;
+        char *printer_dn = NULL;
 
         /* build the ads mods */
@@ -266 +439 @@
         DEBUG(5, ("publishing printer %s\n", printer));
 
-        /* figure out where to publish */
-        ads_rc = ads_find_machine_acct(ads, &res, global_myname());
-        if (!ADS_ERR_OK(ads_rc)) {
-                DEBUG(0, ("failed to find machine account for %s\n",
-                          global_myname()));
+        win_rc = nt_printer_dn_lookup(ctx, ads, printer, &printer_dn);
+        if (!W_ERROR_IS_OK(win_rc)) {
+                DEBUG(2, ("Failed to create printer dn\n"));
                 TALLOC_FREE(ctx);
-                return WERR_NOT_FOUND;
-        }
-
-        /* We use ldap_get_dn here as we need the answer
-         * in utf8 to call ldap_explode_dn(). JRA. */
-
-        srv_dn_utf8 = ldap_get_dn((LDAP *)ads->ldap.ld, (LDAPMessage *)res);
-        ads_msgfree(ads, res);
-        if (!srv_dn_utf8) {
-                TALLOC_FREE(ctx);
-                return WERR_SERVER_UNAVAILABLE;
-        }
-        srv_cn_utf8 = ldap_explode_dn(srv_dn_utf8, 1);
-        if (!srv_cn_utf8) {
-                TALLOC_FREE(ctx);
-                ldap_memfree(srv_dn_utf8);
-                return WERR_SERVER_UNAVAILABLE;
-        }
-        /* Now convert to CH_UNIX. */
-        if (!pull_utf8_talloc(ctx, &srv_dn, srv_dn_utf8, &converted_size)) {
-                TALLOC_FREE(ctx);
-                ldap_memfree(srv_dn_utf8);
-                ldap_memfree(srv_cn_utf8);
-                return WERR_SERVER_UNAVAILABLE;
-        }
-        if (!pull_utf8_talloc(ctx, &srv_cn_0, srv_cn_utf8[0], &converted_size)) {
-                TALLOC_FREE(ctx);
-                ldap_memfree(srv_dn_utf8);
-                ldap_memfree(srv_cn_utf8);
-                TALLOC_FREE(srv_dn);
-                return WERR_SERVER_UNAVAILABLE;
-        }
-
-        ldap_memfree(srv_dn_utf8);
-        ldap_memfree(srv_cn_utf8);
-
-        srv_cn_escaped = escape_rdn_val_string_alloc(srv_cn_0);
-        if (!srv_cn_escaped) {
-                TALLOC_FREE(ctx);
-                return WERR_SERVER_UNAVAILABLE;
-        }
-        sharename_escaped = escape_rdn_val_string_alloc(printer);
-        if (!sharename_escaped) {
-                SAFE_FREE(srv_cn_escaped);
-                TALLOC_FREE(ctx);
-                return WERR_SERVER_UNAVAILABLE;
-        }
-
-        prt_dn = talloc_asprintf(ctx, "cn=%s-%s,%s", srv_cn_escaped, sharename_escaped, srv_dn);
-
-        SAFE_FREE(srv_cn_escaped);
-        SAFE_FREE(sharename_escaped);
+                return win_rc;
+        }
 
         mods = ads_init_mods(ctx);
@@ -339 +460 @@
 
         /* publish it */
-        ads_rc = ads_mod_printer_entry(ads, prt_dn, ctx, &mods);
+        ads_rc = ads_mod_printer_entry(ads, printer_dn, ctx, &mods);
         if (ads_rc.err.rc == LDAP_NO_SUCH_OBJECT) {
                 int i;
@@ -345 +466 @@
                         ;
                 mods[i] = (LDAPMod *)-1;
-                ads_rc = ads_add_printer_entry(ads, prt_dn, ctx, &mods);
+                ads_rc = ads_add_printer_entry(ads, printer_dn, ctx, &mods);
         }
 
@@ -351 +472 @@
                 DEBUG(3, ("error publishing %s: %s\n",
                           printer, ads_errstr(ads_rc)));
-        }
-
-        /* retreive the guid and store it locally */
-        if (ADS_ERR_OK(ads_search_dn(ads, &res, prt_dn, attrs))) {
-                bool guid_ok;
-                ZERO_STRUCT(guid);
-                guid_ok = ads_pull_guid(ads, res, &guid);
-                ads_msgfree(ads, res);
-                if (guid_ok) {
-                        store_printer_guid(msg_ctx, printer, guid);
-                }
-        }
+                /* XXX failed to publish, so no guid to retrieve */
+        }
+
+        win_rc = nt_printer_guid_retrieve_internal(ads, printer_dn, &guid);
+        if (!W_ERROR_IS_OK(win_rc)) {
+                TALLOC_FREE(ctx);
+                return win_rc;
+        }
+
+        win_rc = nt_printer_guid_store(msg_ctx, printer, guid);
+        if (!W_ERROR_IS_OK(win_rc)) {
+                DEBUG(3, ("failed to store printer %s guid\n",
+                          printer));
+                /* not catastrophic, retrieve on next use */
+                win_rc = WERR_OK;
+        }
+
         TALLOC_FREE(ctx);
 
@@ -379 +505 @@
         /* remove the printer from the directory */
         ads_rc = ads_find_printer_on_server(ads, &res,
-                                            printer, global_myname());
+                                            printer, lp_netbios_name());
 
         if (ADS_ERR_OK(ads_rc) && res && ads_count_replies(ads, res)) {
@@ -408 +534 @@
 
 WERROR nt_printer_publish(TALLOC_CTX *mem_ctx,
-                          const struct auth_serversupplied_info *session_info,
+                          const struct auth_session_info *session_info,
                           struct messaging_context *msg_ctx,
                           struct spoolss_PrinterInfo2 *pinfo2,
@@ -418 +544 @@
         ADS_STRUCT *ads = NULL;
         WERROR win_rc;
+        char *old_krb5ccname = NULL;
 
         sinfo2 = talloc_zero(mem_ctx, struct spoolss_SetPrinterInfo2);
@@ -455 +582 @@
                 goto done;
         }
+        old_krb5ccname = getenv(KRB5_ENV_CCNAME);
         setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
         SAFE_FREE(ads->auth.password);
@@ -480 +608 @@
 done:
         ads_destroy(&ads);
+        ads_kdestroy("MEMORY:prtpub_cache");
+        unsetenv(KRB5_ENV_CCNAME);
+        if (old_krb5ccname) {
+                setenv(KRB5_ENV_CCNAME, old_krb5ccname, 0);
+        }
         return win_rc;
 }
@@ -490 +623 @@
         int n_services = lp_numservices();
         TALLOC_CTX *tmp_ctx = NULL;
-        struct auth_serversupplied_info *session_info = NULL;
+        struct auth_session_info *session_info = NULL;
         struct spoolss_PrinterInfo2 *pinfo2;
         NTSTATUS status;
         WERROR result;
+        char *old_krb5ccname = NULL;
 
         tmp_ctx = talloc_new(NULL);
@@ -503 +637 @@
                 return WERR_SERVER_UNAVAILABLE;
         }
+        old_krb5ccname = getenv(KRB5_ENV_CCNAME);
         setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
         SAFE_FREE(ads->auth.password);
@@ -525 +660 @@
 
         for (snum = 0; snum < n_services; snum++) {
-                if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
+                if (!lp_snum_ok(snum) || !lp_printable(snum)) {
                         continue;
                 }
 
                 result = winreg_get_printer_internal(tmp_ctx, session_info, msg_ctx,
-                                            lp_servicename(snum),
+                                            lp_servicename(talloc_tos(), snum),
                                             &pinfo2);
                 if (!W_ERROR_IS_OK(result)) {
@@ -547 +682 @@
         ads_destroy(&ads);
         ads_kdestroy("MEMORY:prtpub_cache");
+        unsetenv(KRB5_ENV_CCNAME);
+        if (old_krb5ccname) {
+                setenv(KRB5_ENV_CCNAME, old_krb5ccname, 0);
+        }
         talloc_free(tmp_ctx);
         return result;
@@ -552 +691 @@
 
 bool is_printer_published(TALLOC_CTX *mem_ctx,
-                          const struct auth_serversupplied_info *session_info,
+                          const struct auth_session_info *session_info,
                           struct messaging_context *msg_ctx,
                           const char *servername,
@@ -588 +727 @@
 }
 #else
+WERROR nt_printer_guid_store(struct messaging_context *msg_ctx,
+                           const char *printer, struct GUID guid)
+{
+        return WERR_NOT_SUPPORTED;
+}
+
+WERROR nt_printer_guid_retrieve(TALLOC_CTX *mem_ctx, const char *printer,
+                                struct GUID *pguid)
+{
+        return WERR_NOT_SUPPORTED;
+}
+
 WERROR nt_printer_guid_get(TALLOC_CTX *mem_ctx,
-                           const struct auth_serversupplied_info *session_info,
+                           const struct auth_session_info *session_info,
                            struct messaging_context *msg_ctx,
                            const char *printer, struct GUID *guid)
@@ -597 +748 @@
 
 WERROR nt_printer_publish(TALLOC_CTX *mem_ctx,
-                          const struct auth_serversupplied_info *session_info,
+                          const struct auth_session_info *session_info,
                           struct messaging_context *msg_ctx,
                           struct spoolss_PrinterInfo2 *pinfo2,
@@ -611 +762 @@
 
 bool is_printer_published(TALLOC_CTX *mem_ctx,
-                          const struct auth_serversupplied_info *session_info,
+                          const struct auth_session_info *session_info,
                           struct messaging_context *msg_ctx,
                           const char *servername,

vendor/current/source3/printing/nt_printing_migrate.c

@@ -4 +4 @@
  *
  *  Copyright (c) Andreas Schneider            2010.
- *  Copyright (C) Bjoern Baumbach <bb@sernet.de> 2011
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -28 +27 @@
 #include "librpc/gen_ndr/ndr_security.h"
 #include "rpc_client/cli_winreg_spoolss.h"
-
-static const char *driver_file_basename(const char *file)
-{
-        const char *basefile;
-
-        basefile = strrchr(file, '\\');
-        if (basefile == NULL) {
-                basefile = file;
-        } else {
-                basefile++;
-        }
-
-        return basefile;
-}
 
 NTSTATUS printing_tdb_migrate_form(TALLOC_CTX *mem_ctx,
@@ -117 +102 @@
         const char *driver_name;
         uint32_t driver_version;
-        int i;
 
         blob = data_blob_const(data, length);
@@ -140 +124 @@
         ZERO_STRUCT(a);
 
-        /* remove paths from file names */
-        if (r.dependent_files != NULL) {
-                for (i = 0 ; r.dependent_files[i] != NULL; i++) {
-                        r.dependent_files[i] = driver_file_basename(r.dependent_files[i]);
-                }
-        }
         a.string = r.dependent_files;
-
-        r.driverpath = driver_file_basename(r.driverpath);
-        r.configfile = driver_file_basename(r.configfile);
-        r.datafile = driver_file_basename(r.datafile);
-        r.helpfile = driver_file_basename(r.helpfile);
 
         d3.architecture = r.environment;
@@ -290 +263 @@
 
                 devmode_ctr.devmode = &dm;
-
-                info2.devmode_ptr = 1;
         }
 
@@ -310 +281 @@
         for (j = 0; j < r.count; j++) {
                 char *valuename;
-                char *keyname;
+                const char *keyname;
 
                 if (r.printer_data[j].type == REG_NONE) {
@@ -316 +287 @@
                 }
 
-                keyname = CONST_DISCARD(char *, r.printer_data[j].name);
+                keyname = r.printer_data[j].name;
                 valuename = strchr(keyname, '\\');
                 if (valuename == NULL) {

vendor/current/source3/printing/nt_printing_migrate_internal.c

@@ -187 +187 @@
 bool nt_printing_tdb_migrate(struct messaging_context *msg_ctx)
 {
-        const char *drivers_path = state_path("ntdrivers.tdb");
-        const char *printers_path = state_path("ntprinters.tdb");
-        const char *forms_path = state_path("ntforms.tdb");
-        bool drivers_exists = file_exist(drivers_path);
-        bool printers_exists = file_exist(printers_path);
-        bool forms_exists = file_exist(forms_path);
-        struct auth_serversupplied_info *session_info;
+        const char *drivers_path;
+        const char *printers_path;
+        const char *forms_path;
+        bool drivers_exists;
+        bool printers_exists;
+        bool forms_exists;
+        struct auth_session_info *session_info;
         struct rpc_pipe_client *winreg_pipe = NULL;
         TALLOC_CTX *tmp_ctx = talloc_stackframe();
         NTSTATUS status;
 
+        /* paths talloced on new stackframe */
+        drivers_path = state_path("ntdrivers.tdb");
+        printers_path = state_path("ntprinters.tdb");
+        forms_path = state_path("ntforms.tdb");
+        if ((drivers_path == NULL) || (printers_path == NULL)
+                                                || (forms_path == NULL)) {
+                talloc_free(tmp_ctx);
+                return false;
+        }
+        drivers_exists = file_exist(drivers_path);
+        printers_exists = file_exist(printers_path);
+        forms_exists = file_exist(forms_path);
+
         if (!drivers_exists && !printers_exists && !forms_exists) {
+                talloc_free(tmp_ctx);
                 return true;
         }
@@ -211 +225 @@
 
         status = rpc_pipe_open_interface(tmp_ctx,
-                                        &ndr_table_winreg.syntax_id,
+                                        &ndr_table_winreg,
                                         session_info,
                                         NULL,

vendor/current/source3/printing/nt_printing_os2.c

@@ -74 +74 @@
 WERROR spoolss_map_to_os2_driver(TALLOC_CTX *mem_ctx, const char **pdrivername)
 {
-        const char *mapfile = lp_os2_driver_map();
+        const char *mapfile = lp_os2_driver_map(talloc_tos());
         char **lines = NULL;
         const char *drivername;

vendor/current/source3/printing/nt_printing_tdb.c

@@ -55 +55 @@
 
         fstrcpy(share, sharename);
-        strlower_m(share);
+        (void)strlower_m(share);
 
         keystr = talloc_asprintf(ctx, "%s%s", PRINTERS_PREFIX, share);
@@ -75 +75 @@
 
         fstrcpy(share, sharename );
-        strlower_m(share);
+        (void)strlower_m(share);
 
         keystr = talloc_asprintf(ctx, "%s%s", SECDESC_PREFIX, share);
@@ -94 +94 @@
 
         for (kbuf = tdb_firstkey(tdb_drivers); kbuf.dptr;
-                        newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
+             newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
 
                 dbuf = tdb_fetch(tdb_drivers, kbuf);
@@ -163 +163 @@
         TALLOC_CTX *ctx = state;
         int result, i;
-        uint32 sd_size;
         size_t size_new_sec;
 
@@ -237 +236 @@
         /* store it back */
 
-        sd_size = ndr_size_security_descriptor(sd_store->sd, 0)
-                + sizeof(struct sec_desc_buf);
-
         status = marshall_sec_desc_buf(ctx, sd_store, &data.dptr, &data.dsize);
         if (!NT_STATUS_IS_OK(status)) {
@@ -250 +246 @@
         /* 0 to continue and non-zero to stop traversal */
 
-        return (result == -1);
+        return (result != 0);
 }
 
@@ -271 +267 @@
         talloc_destroy( ctx );
 
-        return ( result != -1 );
+        return ( result >= 0 );
 }
 
@@ -339 +335 @@
         talloc_destroy( ctx );
 
-        return ( result != -1 );
+        return ( result >= 0 );
 }
 
 bool nt_printing_tdb_upgrade(void)
 {
-        const char *drivers_path = state_path("ntdrivers.tdb");
-        const char *printers_path = state_path("ntprinters.tdb");
-        const char *forms_path = state_path("ntforms.tdb");
-        bool drivers_exists = file_exist(drivers_path);
-        bool printers_exists = file_exist(printers_path);
-        bool forms_exists = file_exist(forms_path);
+        char *drivers_path;
+        char *printers_path;
+        char *forms_path;
+        bool drivers_exists;
+        bool printers_exists;
+        bool forms_exists;
         const char *vstring = "INFO/version";
         int32_t vers_id;
+        bool ret;
+
+        drivers_path = state_path("ntdrivers.tdb");
+        if (drivers_path == NULL) {
+                ret = false;
+                goto err_out;
+        }
+        printers_path = state_path("ntprinters.tdb");
+        if (printers_path == NULL) {
+                ret = false;
+                goto err_drvdb_free;
+        }
+        forms_path = state_path("ntforms.tdb");
+        if (forms_path == NULL) {
+                ret = false;
+                goto err_prdb_free;
+        }
+
+        drivers_exists = file_exist(drivers_path);
+        printers_exists = file_exist(printers_path);
+        forms_exists = file_exist(forms_path);
 
         if (!drivers_exists && !printers_exists && !forms_exists) {
-                return true;
+                ret = true;
+                goto err_formsdb_free;
         }
 
@@ -366 +384 @@
                          "database %s (%s)\n",
                          drivers_path, strerror(errno)));
-                return false;
+                ret = false;
+                goto err_formsdb_free;
         }
 
@@ -378 +397 @@
                          "database %s (%s)\n",
                          printers_path, strerror(errno)));
-                return false;
+                ret = false;
+                goto err_drvdb_close;
         }
 
@@ -390 +410 @@
                          "database %s (%s)\n",
                          forms_path, strerror(errno)));
-                return false;
+                ret = false;
+                goto err_prdb_close;
         }
 
@@ -405 +426 @@
                     (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_1)) {
                         if (!upgrade_to_version_3()) {
-                                return false;
+                                ret = false;
+                                goto err_formsdb_close;
                         }
 
@@ -425 +447 @@
                 if (vers_id == NTDRIVERS_DATABASE_VERSION_3) {
                         if (!upgrade_to_version_4()) {
-                                return false;
+                                ret = false;
+                                goto err_formsdb_close;
                         }
                         tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_4);
@@ -433 +456 @@
                 if (vers_id == NTDRIVERS_DATABASE_VERSION_4 ) {
                         if (!upgrade_to_version_5()) {
-                                return false;
+                                ret = false;
+                                goto err_formsdb_close;
                         }
                         tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5);
@@ -441 +465 @@
                 if (vers_id != NTDRIVERS_DATABASE_VERSION_5) {
                         DEBUG(0,("nt_printing_init: Unknown printer database version [%d]\n", vers_id));
-                        return false;
-                }
-        }
-
+                        ret = false;
+                        goto err_formsdb_close;
+                }
+        }
+        ret = true;
+
+err_formsdb_close:
+        if (tdb_forms) {
+                tdb_close(tdb_forms);
+                tdb_forms = NULL;
+        }
+err_prdb_close:
+        if (tdb_printers) {
+                tdb_close(tdb_printers);
+                tdb_printers = NULL;
+        }
+err_drvdb_close:
         if (tdb_drivers) {
                 tdb_close(tdb_drivers);
                 tdb_drivers = NULL;
         }
-
-        if (tdb_printers) {
-                tdb_close(tdb_printers);
-                tdb_printers = NULL;
-        }
-
-        if (tdb_forms) {
-                tdb_close(tdb_forms);
-                tdb_forms = NULL;
-        }
-
-        return true;
-}
+err_formsdb_free:
+        talloc_free(forms_path);
+err_prdb_free:
+        talloc_free(printers_path);
+err_drvdb_free:
+        talloc_free(drivers_path);
+err_out:
+        return ret;
+}

vendor/current/source3/printing/pcap.c

@@ -84 +84 @@
 }
 
-bool pcap_cache_add(const char *name, const char *comment, const char *location)
-{
+bool pcap_cache_loaded(time_t *_last_change)
+{
+        NTSTATUS status;
+        time_t last;
+
+        status = printer_list_get_last_refresh(&last);
+        if (!NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        if (_last_change != NULL) {
+                *_last_change = last;
+        }
+        return true;
+}
+
+bool pcap_cache_replace(const struct pcap_cache *pcache)
+{
+        const struct pcap_cache *p;
         NTSTATUS status;
         time_t t = time_mono(NULL);
 
-        status = printer_list_set_printer(talloc_tos(), name, comment, location, t);
-        return NT_STATUS_IS_OK(status);
-}
-
-bool pcap_cache_loaded(void)
-{
-        NTSTATUS status;
-        time_t last;
-
-        status = printer_list_get_last_refresh(&last);
-        return NT_STATUS_IS_OK(status);
-}
-
-bool pcap_cache_replace(const struct pcap_cache *pcache)
-{
-        const struct pcap_cache *p;
-        NTSTATUS status;
-
         status = printer_list_mark_reload();
         if (!NT_STATUS_IS_OK(status)) {
@@ -114 +112 @@
 
         for (p = pcache; p; p = p->next) {
-                pcap_cache_add(p->name, p->comment, p->location);
+                status = printer_list_set_printer(talloc_tos(), p->name,
+                                                  p->comment, p->location, t);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return false;
+                }
         }
 
@@ -133 +135 @@
         const char *pcap_name = lp_printcapname();
         bool pcap_reloaded = False;
-        NTSTATUS status;
         bool post_cache_fill_fn_handled = false;
+        struct pcap_cache *pcache = NULL;
 
         DEBUG(3, ("reloading printcap cache\n"));
@@ -141 +143 @@
         if (pcap_name == NULL || *pcap_name == 0) {
                 DEBUG(0, ("No printcap file name configured!\n"));
-                return;
-        }
-
-        status = printer_list_mark_reload();
-        if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0, ("Failed to mark printer list for reload!\n"));
                 return;
         }
@@ -165 +161 @@
 #ifdef HAVE_IPRINT
         if (strequal(pcap_name, "iprint")) {
-                pcap_reloaded = iprint_cache_reload();
+                pcap_reloaded = iprint_cache_reload(&pcache);
                 goto done;
         }
@@ -172 +168 @@
 #if defined(SYSV) || defined(HPUX)
         if (strequal(pcap_name, "lpstat")) {
-                pcap_reloaded = sysv_cache_reload();
+                pcap_reloaded = sysv_cache_reload(&pcache);
                 goto done;
         }
@@ -179 +175 @@
 #ifdef AIX
         if (strstr_m(pcap_name, "/qconfig") != NULL) {
-                pcap_reloaded = aix_cache_reload();
-                goto done;
-        }
-#endif
-
-        pcap_reloaded = std_pcap_cache_reload(pcap_name);
-
+                pcap_reloaded = aix_cache_reload(&pcache);
+                goto done;
+        }
+#endif
+
+        pcap_reloaded = std_pcap_cache_reload(pcap_name, &pcache);
+
+/* Fix silly compiler warning about done not being used if none of the above
+ * ifdefs are used */
+#if defined(HAVE_CUPS) || defined(HAVE_IPRINT) || defined(SYSV) || defined(HPUX) || defined(AIX)
 done:
+#endif
         DEBUG(3, ("reload status: %s\n", (pcap_reloaded) ? "ok" : "error"));
 
@@ -192 +192 @@
                 /* cleanup old entries only if the operation was successful,
                  * otherwise keep around the old entries until we can
-                 * successfuly reaload */
-                status = printer_list_clean_old();
-                if (!NT_STATUS_IS_OK(status)) {
-                        DEBUG(0, ("Failed to cleanup printer list!\n"));
+                 * successfully reload */
+
+                if (!pcap_cache_replace(pcache)) {
+                        DEBUG(0, ("Failed to replace printer list!\n"));
                 }
+
                 if (post_cache_fill_fn != NULL) {
                         post_cache_fill_fn(ev, msg_ctx);
                 }
         }
+        pcap_cache_destroy_specific(&pcache);
 
         return;
@@ -230 +232 @@
 }
 
-void pcap_printer_fn(void (*fn)(const char *, const char *, const char *, void *), void *pdata)
-{
-        NTSTATUS status;
-
-        status = printer_list_run_fn(fn, pdata);
+void pcap_printer_read_fn(void (*fn)(const char *, const char *, const char *, void *), void *pdata)
+{
+        NTSTATUS status;
+
+        status = printer_list_read_run_fn(fn, pdata);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(3, ("Failed to run fn for all printers!\n"));

vendor/current/source3/printing/pcap.h

@@ -36 +36 @@
 bool pcap_cache_add_specific(struct pcap_cache **ppcache, const char *name, const char *comment, const char *location);
 void pcap_cache_destroy_specific(struct pcap_cache **ppcache);
-bool pcap_cache_add(const char *name, const char *comment, const char *location);
-bool pcap_cache_loaded(void);
+bool pcap_cache_loaded(time_t *_last_change);
 bool pcap_cache_replace(const struct pcap_cache *cache);
 void pcap_printer_fn_specific(const struct pcap_cache *, void (*fn)(const char *, const char *, const char *, void *), void *);
-void pcap_printer_fn(void (*fn)(const char *, const char *, const char *, void *), void *);
+void pcap_printer_read_fn(void (*fn)(const char *, const char *, const char *, void *), void *);
 
 void pcap_cache_reload(struct tevent_context *ev,
@@ -50 +49 @@
 /* The following definitions come from printing/print_aix.c  */
 
-bool aix_cache_reload(void);
+bool aix_cache_reload(struct pcap_cache **_pcache);
 
 /* The following definitions come from printing/print_cups.c  */
@@ -61 +60 @@
 /* The following definitions come from printing/print_iprint.c  */
 
-bool iprint_cache_reload(void);
+bool iprint_cache_reload(struct pcap_cache **_pcache);
 
 /* The following definitions come from printing/print_svid.c  */
 
-bool sysv_cache_reload(void);
+bool sysv_cache_reload(struct pcap_cache **_pcache);
 
 /* The following definitions come from printing/print_standard.c  */
-bool std_pcap_cache_reload(const char *pcap_name);
+bool std_pcap_cache_reload(const char *pcap_name, struct pcap_cache **_pcache);
 
 #endif /* _PRINTING_PCAP_H_ */

vendor/current/source3/printing/print_aix.c

@@ -30 +30 @@
 
 #ifdef AIX
-bool aix_cache_reload(void)
+bool aix_cache_reload(struct pcap_cache **_pcache)
 {
         int iEtat;
@@ -36 +36 @@
         char *line = NULL, *p;
         char *name = NULL;
+        struct pcap_cache *pcache = NULL;
         TALLOC_CTX *ctx = talloc_init("aix_cache_reload");
 
@@ -53 +54 @@
         /* scan qconfig file for searching <printername>:       */
         for (;(line = fgets_slash(NULL, 1024, pfile)); free(line)) {
+                bool ok;
+
                 if (*line == '*' || *line == 0)
                         continue;
@@ -68 +71 @@
                                         name = talloc_strdup(ctx, p);
                                         if (!name) {
+                                                pcap_cache_destroy_specific(&pcache);
                                                 SAFE_FREE(line);
                                                 x_fclose(pfile);
@@ -87 +91 @@
                                 /* probably a good printer ???          */
                                 iEtat = 0;
-                                if (!pcap_cache_add(name, NULL, NULL)) {
+                                ok = pcap_cache_add_specific(&pcache,
+                                                             name, NULL, NULL);
+                                if (!ok) {
+                                        pcap_cache_destroy_specific(&pcache);
                                         SAFE_FREE(line);
                                         x_fclose(pfile);
@@ -102 +109 @@
                                 /* it's a good virtual printer */
                                 iEtat = 0;
-                                if (!pcap_cache_add(name, NULL, NULL)) {
+                                ok = pcap_cache_add_specific(&pcache,
+                                                             name, NULL, NULL);
+                                if (!ok) {
+                                        pcap_cache_destroy_specific(&pcache);
                                         SAFE_FREE(line);
                                         x_fclose(pfile);
@@ -114 +124 @@
         }
 
+        *_pcache = pcache;
         x_fclose(pfile);
         TALLOC_FREE(ctx);

vendor/current/source3/printing/print_cups.c

@@ -27 +27 @@
 #include "printing/pcap.h"
 #include "librpc/gen_ndr/ndr_printcap.h"
+#include "lib/util/sys_rw.h"
 
 #ifdef HAVE_CUPS
@@ -108 +109 @@
         size_t size;
 
-        if (lp_cups_server() != NULL && strlen(lp_cups_server()) > 0) {
-                if (!push_utf8_talloc(frame, &server, lp_cups_server(), &size)) {
+        if (lp_cups_server(talloc_tos()) != NULL && strlen(lp_cups_server(talloc_tos())) > 0) {
+                if (!push_utf8_talloc(frame, &server, lp_cups_server(talloc_tos()), &size)) {
                         return NULL;
                 }
@@ -148 +149 @@
 
         if (http == NULL) {
-                DEBUG(0,("Unable to connect to CUPS server %s:%d - %s\n",
+                DEBUG(3,("Unable to connect to CUPS server %s:%d - %s\n",
                          server, port, strerror(errno)));
         }
@@ -429 +430 @@
 }
 
-static struct fd_event *cache_fd_event;
+static struct tevent_fd *cache_fd_event;
 
 static bool cups_pcap_load_async(struct tevent_context *ev,
@@ -453 +454 @@
         }
 
-        pid = sys_fork();
+        pid = fork();
         if (pid == (pid_t)-1) {
                 DEBUG(10,("cups_pcap_load_async: fork failed %s\n",
@@ -475 +476 @@
         close_all_print_db();
 
-        status = reinit_after_fork(msg_ctx, ev, procid_self(), true);
+        status = reinit_after_fork(msg_ctx, ev, true, NULL);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("cups_pcap_load_async: reinit_after_fork() failed\n"));
@@ -484 +485 @@
         cups_cache_reload_async(fds[1]);
         close(fds[1]);
+        TALLOC_FREE(msg_ctx);
         _exit(0);
 }
@@ -489 +491 @@
 struct cups_async_cb_args {
         int pipe_fd;
-        struct event_context *event_ctx;
+        struct tevent_context *event_ctx;
         struct messaging_context *msg_ctx;
-        void (*post_cache_fill_fn)(struct event_context *,
+        void (*post_cache_fill_fn)(struct tevent_context *,
                                    struct messaging_context *);
 };
 
-static void cups_async_callback(struct event_context *event_ctx,
-                                struct fd_event *event,
-                                uint16 flags,
+static void cups_async_callback(struct tevent_context *event_ctx,
+                                struct tevent_fd *event,
+                                uint16_t flags,
                                 void *p)
 {
@@ -525 +527 @@
 
         if (!NT_STATUS_IS_OK(pcap_data.status)) {
-                DEBUG(0,("failed to retrieve printer list: %s\n",
+                DEBUG(3,("failed to retrieve printer list: %s\n",
                          nt_errstr(pcap_data.status)));
                 goto err_out;
@@ -566 +568 @@
         int *p_pipe_fd;
 
-        cb_args = TALLOC_P(NULL, struct cups_async_cb_args);
+        cb_args = talloc(NULL, struct cups_async_cb_args);
         if (cb_args == NULL) {
                 return false;
@@ -587 +589 @@
 
         /* Trigger an event when the pipe can be read. */
-        cache_fd_event = event_add_fd(ev,
+        cache_fd_event = tevent_add_fd(ev,
                                 NULL, *p_pipe_fd,
-                                EVENT_FD_READ,
+                                TEVENT_FD_READ,
                                 cups_async_callback,
                                 (void *)cb_args);
@@ -956 +958 @@
                      "attributes-natural-language", NULL, language->language);
 
-        if (!push_utf8_talloc(frame, &printername, lp_printername(snum),
+        if (!push_utf8_talloc(frame, &printername,
+                              lp_printername(talloc_tos(), snum),
                               &size)) {
                 goto out;
@@ -993 +996 @@
          */
 
-        if (!push_utf8_talloc(frame, &cupsoptions, lp_cups_options(snum), &size)) {
+        if (!push_utf8_talloc(frame, &cupsoptions,
+                              lp_cups_options(talloc_tos(), snum), &size)) {
                 goto out;
         }
@@ -1015 +1019 @@
                 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
                         DEBUG(0,("Unable to print file to %s - %s\n",
-                                 lp_printername(snum),
+                                 lp_printername(talloc_tos(), snum),
                                  ippErrorString(cupsLastError())));
                 } else {
@@ -1029 +1033 @@
         } else {
                 DEBUG(0,("Unable to print file to `%s' - %s\n",
-                         lp_printername(snum),
+                         lp_printername(talloc_tos(), snum),
                          ippErrorString(cupsLastError())));
         }
@@ -1154 +1158 @@
                      "attributes-natural-language", NULL, language->language);
 
-        ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+        ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
                       "requested-attributes",
                       (sizeof(jattrs) / sizeof(jattrs[0])),
@@ -1454 +1458 @@
                      "attributes-natural-language", NULL, language->language);
 
-        if (!push_utf8_talloc(frame, &printername, lp_printername(snum),
-                              &size)) {
+        if (!push_utf8_talloc(frame, &printername,
+                              lp_printername(talloc_tos(), snum), &size)) {
                 goto out;
         }
@@ -1476 +1480 @@
                 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
                         DEBUG(0,("Unable to pause printer %s - %s\n",
-                                 lp_printername(snum),
+                                 lp_printername(talloc_tos(), snum),
                                 ippErrorString(cupsLastError())));
                 } else {
@@ -1483 +1487 @@
         } else {
                 DEBUG(0,("Unable to pause printer %s - %s\n",
-                         lp_printername(snum),
+                         lp_printername(talloc_tos(), snum),
                         ippErrorString(cupsLastError())));
         }
@@ -1558 +1562 @@
                      "attributes-natural-language", NULL, language->language);
 
-        if (!push_utf8_talloc(frame, &printername, lp_printername(snum),
+        if (!push_utf8_talloc(frame, &printername, lp_printername(talloc_tos(), snum),
                               &size)) {
                 goto out;
@@ -1580 +1584 @@
                 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
                         DEBUG(0,("Unable to resume printer %s - %s\n",
-                                 lp_printername(snum),
+                                 lp_printername(talloc_tos(), snum),
                                 ippErrorString(cupsLastError())));
                 } else {
@@ -1587 +1591 @@
         } else {
                 DEBUG(0,("Unable to resume printer %s - %s\n",
-                         lp_printername(snum),
+                         lp_printername(talloc_tos(), snum),
                         ippErrorString(cupsLastError())));
         }

vendor/current/source3/printing/print_generic.c

@@ -74 +74 @@
         if (do_sub && snum != -1) {
                 syscmd = talloc_sub_advanced(ctx,
-                                lp_servicename(snum),
+                                lp_servicename(talloc_tos(), snum),
                                 current_user_info.unix_name,
                                 "",
@@ -118 +118 @@
         /* need to pause the spooled entry */
         slprintf(jobstr, sizeof(jobstr)-1, "%d", pjob->sysjob);
-        return print_run_command(snum, lp_printername(snum), True,
-                                 lp_lppausecommand(snum), NULL,
+        return print_run_command(snum, lp_printername(talloc_tos(), snum), True,
+                                 lp_lppause_command(talloc_tos(), snum), NULL,
                                  "%j", jobstr,
                                  NULL);
@@ -133 +133 @@
         /* need to pause the spooled entry */
         slprintf(jobstr, sizeof(jobstr)-1, "%d", pjob->sysjob);
-        return print_run_command(snum, lp_printername(snum), True,
-                                 lp_lpresumecommand(snum), NULL,
+        return print_run_command(snum, lp_printername(talloc_tos(), snum), True,
+                                 lp_lpresume_command(talloc_tos(), snum), NULL,
                                  "%j", jobstr,
                                  NULL);
@@ -216 +216 @@
         /* we print from the directory path to give the best chance of
            parsing the lpq output */
-        current_directory = TALLOC_ARRAY(ctx,
-                                        char,
-                                        PATH_MAX+1);
+        wd = sys_getwd();
+        if (!wd) {
+                return -1;
+        }
+
+        current_directory = talloc_strdup(ctx, wd);
+        SAFE_FREE(wd);
+
         if (!current_directory) {
                 return -1;
         }
-        wd = sys_getwd(current_directory);
-        if (!wd) {
-                return -1;
-        }
-
         print_directory = talloc_strdup(ctx, pjob->filename);
         if (!print_directory) {
@@ -255 +255 @@
 
         /* send it to the system spooler */
-        ret = print_run_command(snum, lp_printername(snum), True,
-                        lp_printcommand(snum), NULL,
+        ret = print_run_command(snum, lp_printername(talloc_tos(), snum), True,
+                        lp_print_command(talloc_tos(), snum), NULL,
                         "%s", p,
                         "%J", jobname,
@@ -273 +273 @@
          */
         pjob->sysjob = -1;
-        ret = generic_queue_get(lp_printername(snum), printing_type, lpq_cmd,
-                                &q, &status);
+        ret = generic_queue_get(lp_printername(talloc_tos(), snum),
+                                printing_type, lpq_cmd, &q, &status);
         if (ret > 0) {
                 int i;
@@ -296 +296 @@
  out:
 
-        if (chdir(wd) == -1) {
+        if (chdir(current_directory) == -1) {
                 smb_panic("chdir failed in generic_job_submit");
         }
@@ -308 +308 @@
 static int generic_queue_pause(int snum)
 {
-        return print_run_command(snum, lp_printername(snum), True,
-                                 lp_queuepausecommand(snum), NULL, NULL);
+        return print_run_command(snum, lp_printername(talloc_tos(), snum), True,
+                                 lp_queuepause_command(talloc_tos(), snum), NULL, NULL);
 }
 
@@ -317 +317 @@
 static int generic_queue_resume(int snum)
 {
-        return print_run_command(snum, lp_printername(snum), True,
-                                 lp_queueresumecommand(snum), NULL, NULL);
+        return print_run_command(snum, lp_printername(talloc_tos(), snum), True,
+                                 lp_queueresume_command(talloc_tos(), snum), NULL, NULL);
 }
 

vendor/current/source3/printing/print_iprint.c

@@ -94 +94 @@
 static const char *iprint_server(void)
 {
-        if ((lp_iprint_server() != NULL) && (strlen(lp_iprint_server()) > 0)) {
+        const char *server = lp_iprint_server(talloc_tos());
+
+        if ((server != NULL) && (strlen(server) > 0)) {
                 DEBUG(10, ("iprint server explicitly set to %s\n",
-                           lp_iprint_server()));
-                return lp_iprint_server();
+                           server));
+                return server;
         }
 
@@ -205 +207 @@
 static int iprint_cache_add_printer(http_t *http,
                                    int reqId,
-                                   char* url)
+                                   const char *url,
+                                   struct pcap_cache **pcache)
 {
         ipp_t           *request = NULL,        /* IPP Request */
@@ -211 +214 @@
         ipp_attribute_t *attr;                  /* Current attribute */
         cups_lang_t     *language = NULL;       /* Default language */
-        char            *name,                  /* printer-name attribute */
-                        *info,                  /* printer-info attribute */
-                        smb_enabled,            /* smb-enabled attribute */
+        const char      *name,                  /* printer-name attribute */
+                        *info;                  /* printer-info attribute */
+        char            smb_enabled,            /* smb-enabled attribute */
                         secure;                 /* security-enabled attrib. */
 
-        char            *httpPath;      /* path portion of the printer-uri */
+        const char      *httpPath;      /* path portion of the printer-uri */
 
         static const char *pattrs[] =   /* Requested printer attributes */
@@ -341 +344 @@
 
                 if (name != NULL && !secure && smb_enabled) 
-                        pcap_cache_add(name, info, NULL);
+                        pcap_cache_add_specific(pcache, name, info, NULL);
         }
 
@@ -350 +353 @@
 }
 
-bool iprint_cache_reload(void)
+bool iprint_cache_reload(struct pcap_cache **_pcache)
 {
         http_t          *http = NULL;           /* HTTP connection to server */
@@ -358 +361 @@
         cups_lang_t     *language = NULL;       /* Default language */
         int             i;
-        bool ret = False;
+        bool ret = false;
+        struct pcap_cache *pcache = NULL;
 
         DEBUG(5, ("reloading iprint printcap cache\n"));
@@ -437 +441 @@
                                 for (i = 0; i<ippGetCount(attr); i++)
                                 {
-                                        char *url = ippGetString(attr, i, NULL);
+                                        const char *url = ippGetString(attr, i, NULL);
                                         if (!url || !strlen(url))
                                                 continue;
-                                        iprint_cache_add_printer(http, i+2, url);
+                                        iprint_cache_add_printer(http, i+2, url,
+                                                                 &pcache);
                                 }
                         }
@@ -447 +452 @@
         }
 
-        ret = True;
+        ret = true;
+        *_pcache = pcache;
 
  out:
@@ -619 +625 @@
 
         slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(),
-                 lp_printername(snum));
+                 lp_printername(talloc_tos(), snum));
 
         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
@@ -633 +639 @@
 
         slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s",
-                 lp_printername(snum));
+                 lp_printername(talloc_tos(), snum));
 
         if ((response = cupsDoRequest(http, request, httpPath)) != NULL) {
@@ -719 +725 @@
 
         slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(),
-                 lp_printername(snum));
+                 lp_printername(talloc_tos(), snum));
 
         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
@@ -733 +739 @@
 
         slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s",
-                 lp_printername(snum));
+                 lp_printername(talloc_tos(), snum));
 
         if ((response = cupsDoRequest(http, request, httpPath)) != NULL) {
@@ -820 +826 @@
 
         slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(),
-                 lp_printername(snum));
+                 lp_printername(talloc_tos(), snum));
 
         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
@@ -839 +845 @@
         */
 
-        slprintf(uri, sizeof(uri) - 1, "/ipp/%s", lp_printername(snum));
+        slprintf(uri, sizeof(uri) - 1, "/ipp/%s", lp_printername(talloc_tos(), snum));
 
         if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) {
                 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
                         DEBUG(0,("Unable to print file to %s - %s\n",
-                                 lp_printername(snum),
+                                 lp_printername(talloc_tos(), snum),
                                  ippErrorString(cupsLastError())));
                 } else {
@@ -851 +857 @@
         } else {
                 DEBUG(0,("Unable to print file to `%s' - %s\n",
-                         lp_printername(snum),
+                         lp_printername(talloc_tos(), snum),
                          ippErrorString(cupsLastError())));
         }

vendor/current/source3/printing/print_standard.c

@@ -60 +60 @@
 
 /* handle standard printcap - moved from pcap_printer_fn() */
-bool std_pcap_cache_reload(const char *pcap_name)
+bool std_pcap_cache_reload(const char *pcap_name, struct pcap_cache **_pcache)
 {
         XFILE *pcap_file;
         char *pcap_line;
+        struct pcap_cache *pcache = NULL;
 
         if ((pcap_file = x_fopen(pcap_name, O_RDONLY, 0)) == NULL) {
@@ -118 +119 @@
                 }
 
-                if (*name && !pcap_cache_add(name, comment, NULL)) {
+                if ((*name != '\0')
+                 && !pcap_cache_add_specific(&pcache, name, comment, NULL)) {
                         x_fclose(pcap_file);
+                        pcap_cache_destroy_specific(&pcache);
                         return false;
                 }
@@ -125 +128 @@
 
         x_fclose(pcap_file);
+        *_pcache = pcache;
         return true;
 }

vendor/current/source3/printing/print_svid.c

@@ -36 +36 @@
 
 #if defined(SYSV) || defined(HPUX)
-bool sysv_cache_reload(void)
+bool sysv_cache_reload(struct pcap_cache **_pcache)
 {
         char **lines;
         int i;
+        struct pcap_cache *pcache = NULL;
 
 #if defined(HPUX)
@@ -112 +113 @@
                 
                 /* add it to the cache */
-                if (!pcap_cache_add(name, NULL, NULL)) {
+                if (!pcap_cache_add_specific(&pcache, name, NULL, NULL)) {
                         TALLOC_FREE(lines);
-                        return False;
+                        pcap_cache_destroy_specific(&pcache);
+                        return false;
                 }
         }
 
         TALLOC_FREE(lines);
-        return True;
+        *_pcache = pcache;
+        return true;
 }
 

vendor/current/source3/printing/printer_list.c

@@ -20 +20 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_open.h"
 #include "util_tdb.h"
 #include "printer_list.h"
 
-#define PL_DB_NAME() lock_path("printer_list.tdb")
 #define PL_KEY_PREFIX "PRINTERLIST/PRN/"
 #define PL_KEY_FORMAT PL_KEY_PREFIX"%s"
@@ -34 +34 @@
 {
         static struct db_context *db;
+        char *db_path;
 
         if (db != NULL) {
                 return db;
         }
-        db = db_open(NULL, PL_DB_NAME(), 0,
+
+        db_path = lock_path("printer_list.tdb");
+        if (db_path == NULL) {
+                return NULL;
+        }
+
+        db = db_open(NULL, db_path, 0,
                      TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
-                     O_RDWR|O_CREAT, 0644);
+                     O_RDWR|O_CREAT, 0644, DBWRAP_LOCK_ORDER_1,
+                     DBWRAP_FLAG_NONE);
+        TALLOC_FREE(db_path);
         return db;
 }
@@ -90 +99 @@
         }
 
-        data = dbwrap_fetch_bystring_upper(db, key, key);
-        if (data.dptr == NULL) {
+        status = dbwrap_fetch_bystring_upper(db, key, key, &data);
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(6, ("Failed to fetch record! "
                           "The printer database is empty?\n"));
-                status = NT_STATUS_NOT_FOUND;
                 goto done;
         }
@@ -134 +142 @@
         SAFE_FREE(nstr);
         SAFE_FREE(cstr);
+        SAFE_FREE(lstr);
         TALLOC_FREE(key);
         return status;
@@ -149 +158 @@
         uint64_t time_64;
         uint32_t time_h, time_l;
-        const char *str = NULL;
-        const char *str2 = NULL;
         NTSTATUS status;
         int len;
@@ -165 +172 @@
         }
 
-        if (comment) {
-                str = comment;
-        } else {
-                str = "";
-        }
-
-        if (location) {
-                str2 = location;
-        } else {
-                str2 = "";
-        }
-
+        if (comment == NULL) {
+                comment = "";
+        }
+
+        if (location == NULL) {
+                location = "";
+        }
 
         time_64 = last_refresh;
@@ -182 +184 @@
         time_h = time_64 >> 32;
 
-        len = tdb_pack(NULL, 0, PL_DATA_FORMAT, time_h, time_l, name, str, str2);
+        len = tdb_pack(NULL, 0,
+                       PL_DATA_FORMAT,
+                       time_h,
+                       time_l,
+                       name,
+                       comment,
+                       location);
 
         data.dptr = talloc_array(key, uint8_t, len);
@@ -193 +201 @@
 
         len = tdb_pack(data.dptr, data.dsize,
-                       PL_DATA_FORMAT, time_h, time_l, name, str, str2);
+                       PL_DATA_FORMAT,
+                       time_h,
+                       time_l,
+                       name,
+                       comment,
+                       location);
 
         status = dbwrap_store_bystring_upper(db, key, data, TDB_REPLACE);
@@ -217 +230 @@
         ZERO_STRUCT(data);
 
-        data = dbwrap_fetch_bystring(db, talloc_tos(), PL_TIMESTAMP_KEY);
-        if (data.dptr == NULL) {
+        status = dbwrap_fetch_bystring(db, talloc_tos(), PL_TIMESTAMP_KEY, &data);
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1, ("Failed to fetch record!\n"));
-                status = NT_STATUS_NOT_FOUND;
                 goto done;
         }
@@ -226 +238 @@
         ret = tdb_unpack(data.dptr, data.dsize,
                          PL_TSTAMP_FORMAT, &time_h, &time_l);
+        TALLOC_FREE(data.dptr);
         if (ret == -1) {
                 DEBUG(1, ("Failed to un pack printer data"));
@@ -280 +293 @@
 
 static NTSTATUS printer_list_traverse(printer_list_trv_fn_t *fn,
-                                                void *private_data)
-{
-        struct db_context *db;
-        int ret;
+                                      void *private_data,
+                                      bool read_only)
+{
+        struct db_context *db;
+        NTSTATUS status;
 
         db = get_printer_list_db();
@@ -290 +304 @@
         }
 
-        ret = db->traverse(db, fn, private_data);
-        if (ret < 0) {
-                return NT_STATUS_UNSUCCESSFUL;
-        }
-
-        return NT_STATUS_OK;
+        if (read_only) {
+                status = dbwrap_traverse_read(db, fn, private_data, NULL);
+        } else {
+                status = dbwrap_traverse(db, fn, private_data, NULL);
+        }
+
+        return status;
 }
 
@@ -313 +328 @@
         char *location;
         int ret;
+        TDB_DATA key;
+        TDB_DATA value;
+
+        key = dbwrap_record_get_key(rec);
 
         /* skip anything that does not contain PL_DATA_FORMAT data */
-        if (strncmp((char *)rec->key.dptr,
+        if (strncmp((char *)key.dptr,
                     PL_KEY_PREFIX, sizeof(PL_KEY_PREFIX)-1)) {
                 return 0;
         }
 
-        ret = tdb_unpack(rec->value.dptr, rec->value.dsize,
+        value = dbwrap_record_get_value(rec);
+
+        ret = tdb_unpack(value.dptr, value.dsize,
                          PL_DATA_FORMAT, &time_h, &time_l, &name, &comment,
                          &location);
@@ -336 +357 @@
 
         if (refresh < state->last_refresh) {
-                state->status = rec->delete_rec(rec);
+                state->status = dbwrap_record_delete(rec);
                 if (!NT_STATUS_IS_OK(state->status)) {
                         return -1;
@@ -357 +378 @@
         state.status = NT_STATUS_OK;
 
-        status = printer_list_traverse(printer_list_clean_fn, &state);
+        status = printer_list_traverse(printer_list_clean_fn, &state, false);
         if (NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL) &&
             !NT_STATUS_IS_OK(state.status)) {
@@ -381 +402 @@
         char *location;
         int ret;
+        TDB_DATA key;
+        TDB_DATA value;
+
+        key = dbwrap_record_get_key(rec);
 
         /* always skip PL_TIMESTAMP_KEY key */
-        if (strequal((const char *)rec->key.dptr, PL_TIMESTAMP_KEY)) {
+        if (strequal((const char *)key.dptr, PL_TIMESTAMP_KEY)) {
                 return 0;
         }
 
-        ret = tdb_unpack(rec->value.dptr, rec->value.dsize,
+        value = dbwrap_record_get_value(rec);
+
+        ret = tdb_unpack(value.dptr, value.dsize,
                          PL_DATA_FORMAT, &time_h, &time_l, &name, &comment,
                          &location);
@@ -404 +431 @@
 }
 
-NTSTATUS printer_list_run_fn(void (*fn)(const char *, const char *, const char *, void *),
-                             void *private_data)
+NTSTATUS printer_list_read_run_fn(void (*fn)(const char *, const char *, const char *, void *),
+                                  void *private_data)
 {
         struct printer_list_exec_state state;
@@ -414 +441 @@
         state.status = NT_STATUS_OK;
 
-        status = printer_list_traverse(printer_list_exec_fn, &state);
+        status = printer_list_traverse(printer_list_exec_fn, &state, true);
         if (NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL) &&
             !NT_STATUS_IS_OK(state.status)) {

vendor/current/source3/printing/printer_list.h

@@ -101 +101 @@
 NTSTATUS printer_list_clean_old(void);
 
-NTSTATUS printer_list_run_fn(void (*fn)(const char *, const char *, const char *, void *),
-                             void *private_data);
+NTSTATUS printer_list_read_run_fn(void (*fn)(const char *, const char *, const char *, void *),
+                                  void *private_data);
 #endif /* _PRINTER_LIST_H_ */

vendor/current/source3/printing/printing.c

@@ -29 +29 @@
 #include "printing/notify.h"
 #include "printing/pcap.h"
+#include "printing/printer_list.h"
+#include "printing/queue_process.h"
 #include "serverid.h"
 #include "smbd/smbd.h"
@@ -34 +36 @@
 #include "messages.h"
 #include "util_tdb.h"
+#include "lib/param/loadparm.h"
+#include "lib/util/sys_rw_data.h"
 
 extern struct current_user current_user;
@@ -39 +43 @@
 
 /* Current printer interface */
-static bool remove_from_jobs_added(const char* sharename, uint32 jobid);
+static bool remove_from_jobs_added(const char* sharename, uint32_t jobid);
 
 /*
@@ -56 +60 @@
 
 static TDB_CONTEXT *rap_tdb;
-static uint16 next_rap_jobid;
+static uint16_t next_rap_jobid;
 struct rap_jobid_key {
         fstring sharename;
-        uint32  jobid;
+        uint32_t  jobid;
 };
 
@@ -67 +71 @@
 ***************************************************************************/
 
-uint16 pjobid_to_rap(const char* sharename, uint32 jobid)
-{
-        uint16 rap_jobid;
+uint16_t pjobid_to_rap(const char* sharename, uint32_t jobid)
+{
+        uint16_t rap_jobid;
         TDB_DATA data, key;
         struct rap_jobid_key jinfo;
-        uint8 buf[2];
+        uint8_t buf[2];
 
         DEBUG(10,("pjobid_to_rap: called.\n"));
@@ -86 +90 @@
         fstrcpy( jinfo.sharename, sharename );
         jinfo.jobid = jobid;
-        key.dptr = (uint8 *)&jinfo;
+        key.dptr = (uint8_t *)&jinfo;
         key.dsize = sizeof(jinfo);
 
         data = tdb_fetch(rap_tdb, key);
-        if (data.dptr && data.dsize == sizeof(uint16)) {
+        if (data.dptr && data.dsize == sizeof(uint16_t)) {
                 rap_jobid = SVAL(data.dptr, 0);
                 SAFE_FREE(data.dptr);
@@ -113 +117 @@
 }
 
-bool rap_to_pjobid(uint16 rap_jobid, fstring sharename, uint32 *pjobid)
+bool rap_to_pjobid(uint16_t rap_jobid, fstring sharename, uint32_t *pjobid)
 {
         TDB_DATA data, key;
-        uint8 buf[2];
+        uint8_t buf[2];
 
         DEBUG(10,("rap_to_pjobid called.\n"));
@@ -146 +150 @@
 }
 
-void rap_jobid_delete(const char* sharename, uint32 jobid)
+void rap_jobid_delete(const char* sharename, uint32_t jobid)
 {
         TDB_DATA key, data;
-        uint16 rap_jobid;
+        uint16_t rap_jobid;
         struct rap_jobid_key jinfo;
-        uint8 buf[2];
+        uint8_t buf[2];
 
         DEBUG(10,("rap_jobid_delete: called.\n"));
@@ -161 +165 @@
         fstrcpy( jinfo.sharename, sharename );
         jinfo.jobid = jobid;
-        key.dptr = (uint8 *)&jinfo;
+        key.dptr = (uint8_t *)&jinfo;
         key.dsize = sizeof(jinfo);
 
         data = tdb_fetch(rap_tdb, key);
-        if (!data.dptr || (data.dsize != sizeof(uint16))) {
+        if (!data.dptr || (data.dsize != sizeof(uint16_t))) {
                 DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n",
                         (unsigned int)jobid ));
@@ -195 +199 @@
         int services = lp_numservices();
         int snum;
-
-        unlink(cache_path("printing.tdb"));
-        mkdir(cache_path("printing"),0755);
+        bool ok;
+        char *print_cache_path;
+
+        if (!printer_list_parent_init()) {
+                return false;
+        }
+
+        print_cache_path = cache_path("printing");
+        if (print_cache_path == NULL) {
+                return false;
+        }
+        ok = directory_create_or_exist(print_cache_path, 0755);
+        TALLOC_FREE(print_cache_path);
+        if (!ok) {
+                return false;
+        }
+
+        print_cache_path = cache_path("printing.tdb");
+        if (print_cache_path == NULL) {
+                return false;
+        }
+        unlink(print_cache_path);
+        TALLOC_FREE(print_cache_path);
 
         /* handle a Samba upgrade */
@@ -203 +227 @@
         for (snum = 0; snum < services; snum++) {
                 struct tdb_print_db *pdb;
-                if (!lp_print_ok(snum))
+                if (!lp_printable(snum))
                         continue;
 
@@ -209 +233 @@
                 if (!pdb)
                         continue;
-                if (tdb_lock_bystring(pdb->tdb, sversion) == -1) {
+                if (tdb_lock_bystring(pdb->tdb, sversion) != 0) {
                         DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) ));
                         release_print_db(pdb);
@@ -277 +301 @@
 ****************************************************************************/
 
-static TDB_DATA print_key(uint32 jobid, uint32 *tmp)
+static TDB_DATA print_key(uint32_t jobid, uint32_t *tmp)
 {
         TDB_DATA ret;
 
         SIVAL(tmp, 0, jobid);
-        ret.dptr = (uint8 *)tmp;
+        ret.dptr = (uint8_t *)tmp;
         ret.dsize = sizeof(*tmp);
         return ret;
@@ -290 +314 @@
  Pack the devicemode to store it in a tdb.
 ****************************************************************************/
-static int pack_devicemode(struct spoolss_DeviceMode *devmode, uint8 *buf, int buflen)
+static int pack_devicemode(struct spoolss_DeviceMode *devmode, uint8_t *buf, int buflen)
 {
         enum ndr_err_code ndr_err;
@@ -324 +348 @@
 ****************************************************************************/
 static int unpack_devicemode(TALLOC_CTX *mem_ctx,
-                      const uint8 *buf, int buflen,
+                      const uint8_t *buf, int buflen,
                       struct spoolss_DeviceMode **devmode)
 {
@@ -374 +398 @@
 ***********************************************************************/
 
-static int unpack_pjob(TALLOC_CTX *mem_ctx, uint8 *buf, int buflen,
+static int unpack_pjob(TALLOC_CTX *mem_ctx, uint8_t *buf, int buflen,
                        struct printjob *pjob)
 {
         int     len = 0;
         int     used;
-        uint32 pjpid, pjjobid, pjsysjob, pjfd, pjstarttime, pjstatus;
-        uint32 pjsize, pjpage_count, pjspooled, pjsmbjob;
+        uint32_t pjpid, pjjobid, pjsysjob, pjfd, pjstarttime, pjstatus;
+        uint32_t pjsize, pjpage_count, pjspooled, pjsmbjob;
 
         if (!buf || !pjob) {
@@ -435 +459 @@
 static struct printjob *print_job_find(TALLOC_CTX *mem_ctx,
                                        const char *sharename,
-                                       uint32 jobid)
+                                       uint32_t jobid)
 {
         struct printjob         *pjob;
@@ -479 +503 @@
 }
 
-/* Convert a unix jobid to a smb jobid */
-
-struct unixjob_traverse_state {
+struct job_traverse_state {
         int sysjob;
-        uint32 sysjob_to_jobid_value;
+        uint32_t jobid;
 };
 
-static int unixjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
-                               TDB_DATA data, void *private_data)
+/* find spoolss jobid based on sysjob */
+static int sysjob_to_jobid_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
+                                       TDB_DATA data, void *private_data)
 {
         struct printjob *pjob;
-        struct unixjob_traverse_state *state =
-                (struct unixjob_traverse_state *)private_data;
+        struct job_traverse_state *state =
+                (struct job_traverse_state *)private_data;
 
         if (!data.dptr || data.dsize == 0)
@@ -497 +520 @@
 
         pjob = (struct printjob *)data.dptr;
-        if (key.dsize != sizeof(uint32))
+        if (key.dsize != sizeof(uint32_t))
                 return 0;
 
         if (state->sysjob == pjob->sysjob) {
-                state->sysjob_to_jobid_value = pjob->jobid;
+                state->jobid = pjob->jobid;
                 return 1;
         }
@@ -508 +531 @@
 }
 
-static uint32 sysjob_to_jobid_pdb(struct tdb_print_db *pdb, int sysjob)
-{
-        struct unixjob_traverse_state state;
+uint32_t sysjob_to_jobid_pdb(struct tdb_print_db *pdb, int sysjob)
+{
+        struct job_traverse_state state;
 
         state.sysjob = sysjob;
-        state.sysjob_to_jobid_value = (uint32)-1;
-
-        tdb_traverse(pdb->tdb, unixjob_traverse_fn, &state);
-
-        return state.sysjob_to_jobid_value;
+        state.jobid = (uint32_t)-1;
+
+        tdb_traverse(pdb->tdb, sysjob_to_jobid_traverse_fn, &state);
+
+        return state.jobid;
 }
 
@@ -525 +548 @@
 ****************************************************************************/
 
-uint32 sysjob_to_jobid(int unix_jobid)
+uint32_t sysjob_to_jobid(int unix_jobid)
 {
         int services = lp_numservices();
         int snum;
-        struct unixjob_traverse_state state;
+        struct job_traverse_state state;
 
         state.sysjob = unix_jobid;
-        state.sysjob_to_jobid_value = (uint32)-1;
+        state.jobid = (uint32_t)-1;
 
         for (snum = 0; snum < services; snum++) {
                 struct tdb_print_db *pdb;
-                if (!lp_print_ok(snum))
+                if (!lp_printable(snum))
                         continue;
                 pdb = get_print_db_byname(lp_const_servicename(snum));
@@ -542 +565 @@
                         continue;
                 }
-                tdb_traverse(pdb->tdb, unixjob_traverse_fn, &state);
+                tdb_traverse(pdb->tdb, sysjob_to_jobid_traverse_fn, &state);
                 release_print_db(pdb);
-                if (state.sysjob_to_jobid_value != (uint32)-1)
-                        return state.sysjob_to_jobid_value;
-        }
-        return (uint32)-1;
+                if (state.jobid != (uint32_t)-1)
+                        return state.jobid;
+        }
+        return (uint32_t)-1;
+}
+
+/* find sysjob based on spoolss jobid */
+static int jobid_to_sysjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key,
+                                       TDB_DATA data, void *private_data)
+{
+        struct printjob *pjob;
+        struct job_traverse_state *state =
+                (struct job_traverse_state *)private_data;
+
+        if (!data.dptr || data.dsize == 0)
+                return 0;
+
+        pjob = (struct printjob *)data.dptr;
+        if (key.dsize != sizeof(uint32_t))
+                return 0;
+
+        if (state->jobid == pjob->jobid) {
+                state->sysjob = pjob->sysjob;
+                return 1;
+        }
+
+        return 0;
+}
+
+int jobid_to_sysjob_pdb(struct tdb_print_db *pdb, uint32_t jobid)
+{
+        struct job_traverse_state state;
+
+        state.sysjob = -1;
+        state.jobid = jobid;
+
+        tdb_traverse(pdb->tdb, jobid_to_sysjob_traverse_fn, &state);
+
+        return state.sysjob;
 }
 
@@ -575 +633 @@
    appropriate win32 API constant. */
 
-static uint32 map_to_spoolss_status(uint32 lpq_status)
+static uint32_t map_to_spoolss_status(uint32_t lpq_status)
 {
         int i = 0;
@@ -598 +656 @@
 
         SIVAL(&store_jobid, 0, jobid);
-        data.dptr = (uint8 *) &store_jobid;
+        data.dptr = (uint8_t *) &store_jobid;
         data.dsize = 4;
 
@@ -627 +685 @@
         key = string_tdb_data("INFO/jobs_changed");
 
-        if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
+        if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) != 0)
                 goto out;
 
@@ -639 +697 @@
         job_count = data.dsize / 4;
         for (i = 0; i < job_count; i++) {
-                uint32 ch_jobid;
+                uint32_t ch_jobid;
 
                 ch_jobid = IVAL(data.dptr, i*4);
@@ -646 +704 @@
                                 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
                         data.dsize -= 4;
-                        if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
+                        if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) != 0)
                                 goto out;
                         break;
@@ -668 +726 @@
 static void pjob_store_notify(struct tevent_context *ev,
                               struct messaging_context *msg_ctx,
-                              const char* sharename, uint32 jobid,
+                              const char* sharename, uint32_t jobid,
                               struct printjob *old_data,
                               struct printjob *new_data,
@@ -734 +792 @@
 static bool pjob_store(struct tevent_context *ev,
                        struct messaging_context *msg_ctx,
-                       const char* sharename, uint32 jobid,
+                       const char* sharename, uint32_t jobid,
                        struct printjob *pjob)
 {
@@ -741 +799 @@
         bool                    ret = False;
         struct tdb_print_db     *pdb = get_print_db_byname(sharename);
-        uint8                   *buf = NULL;
+        uint8_t                 *buf = NULL;
         int                     len, newlen, buflen;
 
@@ -760 +818 @@
                 buflen = newlen;
                 len += tdb_pack(buf+len, buflen-len, "ddddddddddfffff",
-                                (uint32)pjob->pid,
-                                (uint32)pjob->jobid,
-                                (uint32)pjob->sysjob,
-                                (uint32)pjob->fd,
-                                (uint32)pjob->starttime,
-                                (uint32)pjob->status,
-                                (uint32)pjob->size,
-                                (uint32)pjob->page_count,
-                                (uint32)pjob->spooled,
-                                (uint32)pjob->smbjob,
+                                (uint32_t)pjob->pid,
+                                (uint32_t)pjob->jobid,
+                                (uint32_t)pjob->sysjob,
+                                (uint32_t)pjob->fd,
+                                (uint32_t)pjob->starttime,
+                                (uint32_t)pjob->status,
+                                (uint32_t)pjob->size,
+                                (uint32_t)pjob->page_count,
+                                (uint32_t)pjob->spooled,
+                                (uint32_t)pjob->smbjob,
                                 pjob->filename,
                                 pjob->jobname,
@@ -779 +837 @@
 
                 if (buflen != len) {
-                        buf = (uint8 *)SMB_REALLOC(buf, len);
+                        buf = (uint8_t *)SMB_REALLOC(buf, len);
                         if (!buf) {
                                 DEBUG(0,("pjob_store: failed to enlarge buffer!\n"));
@@ -843 +901 @@
 static void pjob_delete(struct tevent_context *ev,
                         struct messaging_context *msg_ctx,
-                        const char* sharename, uint32 jobid)
+                        const char* sharename, uint32_t jobid)
 {
         uint32_t tmp;
         struct printjob *pjob;
-        uint32 job_status = 0;
+        uint32_t job_status = 0;
         struct tdb_print_db *pdb;
         TALLOC_CTX *tmp_ctx = talloc_new(ev);
@@ -891 +949 @@
                            struct messaging_context *msg_ctx,
                            const char *sharename, print_queue_struct *q,
-                           uint32 jobid)
+                           uint32_t jobid)
 {
         struct printjob pj, *old_pj;
@@ -899 +957 @@
         }
 
-        if (jobid == (uint32)-1) {
+        if (jobid == (uint32_t)-1) {
                 jobid = q->sysjob + UNIX_JOB_START;
         }
@@ -953 +1011 @@
         struct traverse_struct *ts = (struct traverse_struct *)state;
         struct printjob pjob;
-        uint32 jobid;
+        uint32_t jobid;
         int i = 0;
 
@@ -1133 +1191 @@
         TDB_DATA key;
         TDB_DATA data;
-        pid_t updating_pid = sys_getpid();
-        uint8 buffer[4];
+        pid_t updating_pid = getpid();
+        uint8_t buffer[4];
 
         struct tdb_print_db *pdb = get_print_db_byname(sharename);
@@ -1144 +1202 @@
         key = string_tdb_data(keystr);
 
-        DEBUG(5, ("set_updating_pid: %s updating lpq cache for print share %s\n",
+        DEBUG(5, ("set_updating_pid: %supdating lpq cache for print share %s\n",
                 updating ? "" : "not ",
                 sharename ));
@@ -1192 +1250 @@
 {
         TDB_DATA data;
-        int max_reported_jobs = lp_max_reported_jobs(pts->snum);
+        int max_reported_jobs = lp_max_reported_print_jobs(pts->snum);
         print_queue_struct *queue = pts->queue;
         size_t len;
@@ -1212 +1270 @@
                 qcount++;
                 data.dsize += tdb_pack(NULL, 0, "ddddddff",
-                                (uint32)queue[i].sysjob,
-                                (uint32)queue[i].size,
-                                (uint32)queue[i].page_count,
-                                (uint32)queue[i].status,
-                                (uint32)queue[i].priority,
-                                (uint32)queue[i].time,
+                                (uint32_t)queue[i].sysjob,
+                                (uint32_t)queue[i].size,
+                                (uint32_t)queue[i].page_count,
+                                (uint32_t)queue[i].status,
+                                (uint32_t)queue[i].priority,
+                                (uint32_t)queue[i].time,
                                 queue[i].fs_user,
                                 queue[i].fs_file);
         }
 
-        if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL)
+        if ((data.dptr = (uint8_t *)SMB_MALLOC(data.dsize)) == NULL)
                 return;
 
@@ -1232 +1290 @@
 
                 len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
-                                (uint32)queue[i].sysjob,
-                                (uint32)queue[i].size,
-                                (uint32)queue[i].page_count,
-                                (uint32)queue[i].status,
-                                (uint32)queue[i].priority,
-                                (uint32)queue[i].time,
+                                (uint32_t)queue[i].sysjob,
+                                (uint32_t)queue[i].size,
+                                (uint32_t)queue[i].page_count,
+                                (uint32_t)queue[i].status,
+                                (uint32_t)queue[i].priority,
+                                (uint32_t)queue[i].time,
                                 queue[i].fs_user,
                                 queue[i].fs_file);
@@ -1263 +1321 @@
 }
 
-static void check_job_added(const char *sharename, TDB_DATA data, uint32 jobid)
+static void check_job_added(const char *sharename, TDB_DATA data, uint32_t jobid)
 {
         unsigned int i;
@@ -1269 +1327 @@
 
         for (i = 0; i < job_count; i++) {
-                uint32 ch_jobid;
+                uint32_t ch_jobid;
 
                 ch_jobid = IVAL(data.dptr, i*4);
@@ -1305 +1363 @@
 
         if (last_qscan_time == ((time_t)-1)
-                || (time_now - last_qscan_time) >= lp_lpqcachetime()
+                || (time_now - last_qscan_time) >= lp_lpq_cache_time()
                 || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME))
         {
-                uint32 u;
+                uint32_t u;
                 time_t msg_pending_time;
 
@@ -1314 +1372 @@
                         "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n",
                         sharename, (int)last_qscan_time, (int)time_now,
-                        (int)lp_lpqcachetime() ));
+                        (int)lp_lpq_cache_time() ));
 
                 /* check if another smbd has already sent a message to update the
@@ -1408 +1466 @@
 
         for (i=0; i<qcount; i++) {
-                uint32 jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
-                if (jobid == (uint32)-1) {
+                uint32_t jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
+                if (jobid == (uint32_t)-1) {
                         /* assume its a unix print job */
                         print_unix_job(ev, msg_ctx,
@@ -1478 +1536 @@
 
         status.qcount = qcount;
-        data.dptr = (uint8 *)&status;
+        data.dptr = (uint8_t *)&status;
         data.dsize = sizeof(status);
         tdb_store(pdb->tdb, key, data, TDB_REPLACE);
@@ -1488 +1546 @@
 
         slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename);
-        tdb_store_int32(pdb->tdb, keystr, (int32)time(NULL));
+        tdb_store_int32(pdb->tdb, keystr, (int32_t)time(NULL));
 
         /* clear the msg pending record for this queue */
@@ -1546 +1604 @@
         slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename);
         /* Only wait 10 seconds for this. */
-        if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) == -1) {
+        if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) != 0) {
                 DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename));
                 release_print_db(pdb);
@@ -1606 +1664 @@
         size_t len;
 
-        len = tdb_unpack( (uint8 *)data->data, data->length, "fdPP",
+        len = tdb_unpack( (uint8_t *)data->data, data->length, "fdPP",
                 sharename,
                 &printing_type,
@@ -1628 +1686 @@
 }
 
-static void printing_pause_fd_handler(struct tevent_context *ev,
-                                      struct tevent_fd *fde,
-                                      uint16_t flags,
-                                      void *private_data)
-{
-        /*
-         * If pause_pipe[1] is closed it means the parent smbd
-         * and children exited or aborted.
-         */
-        exit_server_cleanly(NULL);
-}
-
-extern struct child_pid *children;
-extern int num_children;
-
-static void add_child_pid(pid_t pid)
-{
-        struct child_pid *child;
-
-        child = SMB_MALLOC_P(struct child_pid);
-        if (child == NULL) {
-                DEBUG(0, ("Could not add child struct -- malloc failed\n"));
-                return;
-        }
-        child->pid = pid;
-        DLIST_ADD(children, child);
-        num_children += 1;
-}
-
-/****************************************************************************
- Notify smbds of new printcap data
-**************************************************************************/
-static void reload_pcap_change_notify(struct tevent_context *ev,
-                                      struct messaging_context *msg_ctx)
-{
-        /*
-         * Reload the printers first in the background process so that
-         * newly added printers get default values created in the registry.
-         *
-         * This will block the process for some time (~1 sec per printer), but
-         * it doesn't block smbd's servering clients.
-         */
-        reload_printers_full(ev, msg_ctx);
-
-        message_send_all(msg_ctx, MSG_PRINTER_PCAP, NULL, 0, NULL);
-}
-
-static bool printer_housekeeping_fn(const struct timeval *now,
-                                    void *private_data)
-{
-        static time_t last_pcap_reload_time = 0;
-        time_t printcap_cache_time = (time_t)lp_printcap_cache_time();
-        time_t t = time_mono(NULL);
-
-        DEBUG(5, ("printer housekeeping\n"));
-
-        /* if periodic printcap rescan is enabled, see if it's time to reload */
-        if ((printcap_cache_time != 0)
-         && (t >= (last_pcap_reload_time + printcap_cache_time))) {
-                DEBUG( 3,( "Printcap cache time expired.\n"));
-                pcap_cache_reload(server_event_context(),
-                                  smbd_messaging_context(),
-                                  &reload_pcap_change_notify);
-                last_pcap_reload_time = t;
-        }
-
-        return true;
-}
-
-static void printing_sig_term_handler(struct tevent_context *ev,
-                                      struct tevent_signal *se,
-                                      int signum,
-                                      int count,
-                                      void *siginfo,
-                                      void *private_data)
-{
-        exit_server_cleanly("termination signal");
-}
-
-static void printing_sig_hup_handler(struct tevent_context *ev,
-                                  struct tevent_signal *se,
-                                  int signum,
-                                  int count,
-                                  void *siginfo,
-                                  void *private_data)
-{
-        struct messaging_context *msg_ctx = talloc_get_type_abort(
-                private_data, struct messaging_context);
-
-        DEBUG(1,("Reloading printers after SIGHUP\n"));
-        pcap_cache_reload(ev, msg_ctx,
-                          &reload_pcap_change_notify);
-}
-
-static void printing_conf_updated(struct messaging_context *msg,
-                                  void *private_data,
-                                  uint32_t msg_type,
-                                  struct server_id server_id,
-                                  DATA_BLOB *data)
-{
-        DEBUG(5,("Reloading printers after conf change\n"));
-        pcap_cache_reload(messaging_event_context(msg), msg,
-                          &reload_pcap_change_notify);
-}
-
-
-static pid_t background_lpq_updater_pid = -1;
-
-/****************************************************************************
-main thread of the background lpq updater
-****************************************************************************/
-void start_background_queue(struct tevent_context *ev,
-                            struct messaging_context *msg_ctx)
-{
-        /* Use local variables for this as we don't
-         * need to save the parent side of this, just
-         * ensure it closes when the process exits.
-         */
-        int pause_pipe[2];
-
-        DEBUG(3,("start_background_queue: Starting background LPQ thread\n"));
-
-        if (pipe(pause_pipe) == -1) {
-                DEBUG(5,("start_background_queue: cannot create pipe. %s\n", strerror(errno) ));
-                exit(1);
-        }
-
-        background_lpq_updater_pid = sys_fork();
-
-        if (background_lpq_updater_pid == -1) {
-                DEBUG(5,("start_background_queue: background LPQ thread failed to start. %s\n", strerror(errno) ));
-                exit(1);
-        }
-
-        /* Track the printing pid along with other smbd children */
-        add_child_pid(background_lpq_updater_pid);
-
-        if(background_lpq_updater_pid == 0) {
-                struct tevent_fd *fde;
-                int ret;
-                NTSTATUS status;
-                struct tevent_signal *se;
-
-                /* Child. */
-                DEBUG(5,("start_background_queue: background LPQ thread started\n"));
-
-                close(pause_pipe[0]);
-                pause_pipe[0] = -1;
-
-                status = reinit_after_fork(msg_ctx, ev, procid_self(), true);
-
-                if (!NT_STATUS_IS_OK(status)) {
-                        DEBUG(0,("reinit_after_fork() failed\n"));
-                        smb_panic("reinit_after_fork() failed");
-                }
-
-                se = tevent_add_signal(ev, ev, SIGTERM, 0,
-                                       printing_sig_term_handler,
-                                       NULL);
-                if (se == NULL) {
-                        smb_panic("failed to setup SIGTERM handler");
-                }
-                se = tevent_add_signal(ev, ev, SIGHUP, 0,
-                                       printing_sig_hup_handler,
-                                       msg_ctx);
-                if (se == NULL) {
-                        smb_panic("failed to setup SIGHUP handler");
-                }
-
-                if (!serverid_register(procid_self(),
-                                       FLAG_MSG_GENERAL|FLAG_MSG_SMBD
-                                       |FLAG_MSG_PRINT_GENERAL)) {
-                        exit(1);
-                }
-
-                if (!locking_init()) {
-                        exit(1);
-                }
-
-                messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
-                                   print_queue_receive);
-                messaging_register(msg_ctx, NULL, MSG_SMB_CONF_UPDATED,
-                                   printing_conf_updated);
-
-                fde = tevent_add_fd(ev, ev, pause_pipe[1], TEVENT_FD_READ,
-                                    printing_pause_fd_handler,
-                                    NULL);
-                if (!fde) {
-                        DEBUG(0,("tevent_add_fd() failed for pause_pipe\n"));
-                        smb_panic("tevent_add_fd() failed for pause_pipe");
-                }
-
-                /* reload on startup to ensure parent smbd is refreshed */
-                pcap_cache_reload(server_event_context(),
-                                  smbd_messaging_context(),
-                                  &reload_pcap_change_notify);
-
-                if (!(event_add_idle(ev, NULL,
-                                     timeval_set(SMBD_HOUSEKEEPING_INTERVAL, 0),
-                                     "printer_housekeeping",
-                                     printer_housekeeping_fn,
-                                     NULL))) {
-                        DEBUG(0, ("Could not add printing housekeeping event\n"));
-                        exit(1);
-                }
-
-                DEBUG(5,("start_background_queue: background LPQ thread waiting for messages\n"));
-                ret = tevent_loop_wait(ev);
-                /* should not be reached */
-                DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
-                         ret, (ret == 0) ? "out of events" : strerror(errno)));
-                exit(1);
-        }
-
-        close(pause_pipe[1]);
-}
-
 /****************************************************************************
 update the internal database from the system print queue for a queue
 ****************************************************************************/
+
+extern pid_t background_lpq_updater_pid;
 
 static void print_queue_update(struct messaging_context *msg_ctx,
@@ -1856 +1699 @@
         char *lpqcommand = NULL;
         char *lprmcommand = NULL;
-        uint8 *buffer = NULL;
+        uint8_t *buffer = NULL;
         size_t len = 0;
         size_t newlen;
@@ -1869 +1712 @@
 
         lpqcommand = talloc_string_sub2(ctx,
-                        lp_lpqcommand(snum),
+                        lp_lpq_command(talloc_tos(), snum),
                         "%p",
-                        lp_printername(snum),
+                        lp_printername(talloc_tos(), snum),
                         false, false, false);
         if (!lpqcommand) {
@@ -1877 +1720 @@
         }
         lpqcommand = talloc_sub_advanced(ctx,
-                        lp_servicename(snum),
+                        lp_servicename(talloc_tos(), snum),
                         current_user_info.unix_name,
                         "",
@@ -1889 +1732 @@
 
         lprmcommand = talloc_string_sub2(ctx,
-                        lp_lprmcommand(snum),
+                        lp_lprm_command(talloc_tos(), snum),
                         "%p",
-                        lp_printername(snum),
+                        lp_printername(talloc_tos(), snum),
                         false, false, false);
         if (!lprmcommand) {
@@ -1897 +1740 @@
         }
         lprmcommand = talloc_sub_advanced(ctx,
-                        lp_servicename(snum),
+                        lp_servicename(talloc_tos(), snum),
                         current_user_info.unix_name,
                         "",
@@ -1933 +1776 @@
                 lprmcommand );
 
-        buffer = SMB_XMALLOC_ARRAY( uint8, len );
+        buffer = SMB_XMALLOC_ARRAY( uint8_t, len );
 
         /* now pack the buffer */
@@ -1972 +1815 @@
 
         messaging_send_buf(msg_ctx, pid_to_procid(background_lpq_updater_pid),
-                           MSG_PRINTER_UPDATE, (uint8 *)buffer, len);
+                           MSG_PRINTER_UPDATE, (uint8_t *)buffer, len);
 
         SAFE_FREE( buffer );
@@ -1990 +1833 @@
         TDB_CONTEXT *tdb = NULL;
         const char *printername;
-        uint32 mypid = (uint32)sys_getpid();
+        uint32_t mypid = (uint32_t)getpid();
         bool ret = False;
         size_t i;
@@ -2004 +1847 @@
 
                 for ( idx=0; idx<num_services; idx++ ) {
-                        if (lp_snum_ok(idx) && lp_print_ok(idx) )
+                        if (lp_snum_ok(idx) && lp_printable(idx) )
                                 print_notify_register_pid(idx);
                 }
@@ -2019 +1862 @@
         }
 
-        if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
+        if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) != 0) {
                 DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n",
                                         printername));
@@ -2033 +1876 @@
         for (i = 0; i < data.dsize; i += 8) {
                 if (IVAL(data.dptr,i) == mypid) {
-                        uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
+                        uint32_t new_refcount = IVAL(data.dptr, i+4) + 1;
                         SIVAL(data.dptr, i+4, new_refcount);
                         break;
@@ -2041 +1884 @@
         if (i == data.dsize) {
                 /* We weren't in the list. Realloc. */
-                data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
+                data.dptr = (uint8_t *)SMB_REALLOC(data.dptr, data.dsize + 8);
                 if (!data.dptr) {
                         DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n",
@@ -2053 +1896 @@
 
         /* Store back the record. */
-        if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
+        if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) != 0) {
                 DEBUG(0,("print_notify_register_pid: Failed to update pid \
 list for printer %s\n", printername));
@@ -2081 +1924 @@
         TDB_CONTEXT *tdb = NULL;
         const char *printername;
-        uint32 mypid = (uint32)sys_getpid();
+        uint32_t mypid = (uint32_t)getpid();
         size_t i;
         bool ret = False;
@@ -2094 +1937 @@
 
                 for ( idx=0; idx<num_services; idx++ ) {
-                        if ( lp_snum_ok(idx) && lp_print_ok(idx) )
+                        if ( lp_snum_ok(idx) && lp_printable(idx) )
                                 print_notify_deregister_pid(idx);
                 }
@@ -2109 +1952 @@
         }
 
-        if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
+        if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) != 0) {
                 DEBUG(0,("print_notify_register_pid: Failed to lock \
 printer %s database\n", printername));
@@ -2123 +1966 @@
         for (i = 0; i < data.dsize; ) {
                 if (IVAL(data.dptr,i) == mypid) {
-                        uint32 refcount = IVAL(data.dptr, i+4);
+                        uint32_t refcount = IVAL(data.dptr, i+4);
 
                         refcount--;
@@ -2143 +1986 @@
 
         /* Store back the record. */
-        if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) == -1) {
+        if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) != 0) {
                 DEBUG(0,("print_notify_register_pid: Failed to update pid \
 list for printer %s\n", printername));
@@ -2164 +2007 @@
 ****************************************************************************/
 
-bool print_job_exists(const char* sharename, uint32 jobid)
+bool print_job_exists(const char* sharename, uint32_t jobid)
 {
         struct tdb_print_db *pdb = get_print_db_byname(sharename);
@@ -2185 +2028 @@
 struct spoolss_DeviceMode *print_job_devmode(TALLOC_CTX *mem_ctx,
                                              const char *sharename,
-                                             uint32 jobid)
+                                             uint32_t jobid)
 {
         struct printjob *pjob = print_job_find(mem_ctx, sharename, jobid);
@@ -2201 +2044 @@
 bool print_job_set_name(struct tevent_context *ev,
                         struct messaging_context *msg_ctx,
-                        const char *sharename, uint32 jobid, const char *name)
+                        const char *sharename, uint32_t jobid, const char *name)
 {
         struct printjob *pjob;
@@ -2211 +2054 @@
 
         pjob = print_job_find(tmp_ctx, sharename, jobid);
-        if (!pjob || pjob->pid != sys_getpid()) {
+        if (!pjob || pjob->pid != getpid()) {
                 ret = false;
                 goto err_out;
@@ -2232 +2075 @@
 
         pjob = print_job_find(mem_ctx, sharename, jobid);
-        if (!pjob || pjob->pid != sys_getpid()) {
+        if (!pjob || pjob->pid != getpid()) {
                 return false;
         }
@@ -2245 +2088 @@
 ***************************************************************************/
 
-static bool remove_from_jobs_added(const char* sharename, uint32 jobid)
+static bool remove_from_jobs_added(const char* sharename, uint32_t jobid)
 {
         struct tdb_print_db *pdb = get_print_db_byname(sharename);
@@ -2261 +2104 @@
         key = string_tdb_data("INFO/jobs_added");
 
-        if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) == -1)
+        if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) != 0)
                 goto out;
 
@@ -2273 +2116 @@
         job_count = data.dsize / 4;
         for (i = 0; i < job_count; i++) {
-                uint32 ch_jobid;
+                uint32_t ch_jobid;
 
                 ch_jobid = IVAL(data.dptr, i*4);
@@ -2280 +2123 @@
                                 memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
                         data.dsize -= 4;
-                        if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) == -1)
+                        if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) != 0)
                                 goto out;
                         break;
@@ -2306 +2149 @@
 static bool print_job_delete1(struct tevent_context *ev,
                               struct messaging_context *msg_ctx,
-                              int snum, uint32 jobid)
+                              int snum, uint32_t jobid)
 {
         const char* sharename = lp_const_servicename(snum);
@@ -2350 +2193 @@
         {
                 result = (*(current_printif->job_delete))(
-                        lp_printername(snum),
-                        lp_lprmcommand(snum),
+                        lp_printername(talloc_tos(), snum),
+                        lp_lprm_command(talloc_tos(), snum),
                         pjob);
 
@@ -2384 +2227 @@
 ****************************************************************************/
 
-static bool is_owner(const struct auth_serversupplied_info *server_info,
+static bool is_owner(const struct auth_session_info *server_info,
                      const char *servicename,
-                     uint32 jobid)
+                     uint32_t jobid)
 {
         struct printjob *pjob;
@@ -2401 +2244 @@
         }
 
-        ret = strequal(pjob->user, server_info->sanitized_username);
+        ret = strequal(pjob->user, server_info->unix_info->sanitized_username);
 err_out:
         talloc_free(tmp_ctx);
@@ -2411 +2254 @@
 ****************************************************************************/
 
-WERROR print_job_delete(const struct auth_serversupplied_info *server_info,
+WERROR print_job_delete(const struct auth_session_info *server_info,
                         struct messaging_context *msg_ctx,
                         int snum, uint32_t jobid)
@@ -2430 +2273 @@
 
         if (!owner &&
-            !print_access_check(server_info, msg_ctx, snum,
-                                JOB_ACCESS_ADMINISTER)) {
-                DEBUG(3, ("delete denied by security descriptor\n"));
-
-                /* BEGIN_ADMIN_LOG */
-                sys_adminlog( LOG_ERR,
-                              "Permission denied-- user not allowed to delete, \
-pause, or resume print job. User name: %s. Printer name: %s.",
-                              uidtoname(server_info->utok.uid),
-                              lp_printername(snum) );
-                /* END_ADMIN_LOG */
+            !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+                                              JOB_ACCESS_ADMINISTER))) {
+                DEBUG(0, ("print job delete denied."
+                          "User name: %s, Printer name: %s.",
+                          uidtoname(server_info->unix_token->uid),
+                          lp_printername(tmp_ctx, snum)));
 
                 werr = WERR_ACCESS_DENIED;
@@ -2490 +2328 @@
 ****************************************************************************/
 
-WERROR print_job_pause(const struct auth_serversupplied_info *server_info,
+WERROR print_job_pause(const struct auth_session_info *server_info,
                      struct messaging_context *msg_ctx,
-                     int snum, uint32 jobid)
+                     int snum, uint32_t jobid)
 {
         const char* sharename = lp_const_servicename(snum);
@@ -2520 +2358 @@
 
         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
-            !print_access_check(server_info, msg_ctx, snum,
-                                JOB_ACCESS_ADMINISTER)) {
-                DEBUG(3, ("pause denied by security descriptor\n"));
-
-                /* BEGIN_ADMIN_LOG */
-                sys_adminlog( LOG_ERR,
-                        "Permission denied-- user not allowed to delete, \
-pause, or resume print job. User name: %s. Printer name: %s.",
-                              uidtoname(server_info->utok.uid),
-                              lp_printername(snum) );
-                /* END_ADMIN_LOG */
+            !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+                                              JOB_ACCESS_ADMINISTER))) {
+                DEBUG(0, ("print job pause denied."
+                          "User name: %s, Printer name: %s.",
+                          uidtoname(server_info->unix_token->uid),
+                          lp_printername(tmp_ctx, snum)));
 
                 werr = WERR_ACCESS_DENIED;
@@ -2563 +2396 @@
 ****************************************************************************/
 
-WERROR print_job_resume(const struct auth_serversupplied_info *server_info,
+WERROR print_job_resume(const struct auth_session_info *server_info,
                       struct messaging_context *msg_ctx,
-                      int snum, uint32 jobid)
+                      int snum, uint32_t jobid)
 {
         const char *sharename = lp_const_servicename(snum);
@@ -2592 +2425 @@
 
         if (!is_owner(server_info, lp_const_servicename(snum), jobid) &&
-            !print_access_check(server_info, msg_ctx, snum,
-                                JOB_ACCESS_ADMINISTER)) {
-                DEBUG(3, ("resume denied by security descriptor\n"));
-
-                /* BEGIN_ADMIN_LOG */
-                sys_adminlog( LOG_ERR,
-                         "Permission denied-- user not allowed to delete, \
-pause, or resume print job. User name: %s. Printer name: %s.",
-                              uidtoname(server_info->utok.uid),
-                              lp_printername(snum) );
-                /* END_ADMIN_LOG */
+            !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+                                              JOB_ACCESS_ADMINISTER))) {
+                DEBUG(0, ("print job resume denied."
+                          "User name: %s, Printer name: %s.",
+                          uidtoname(server_info->unix_token->uid),
+                          lp_printername(tmp_ctx, snum)));
+
                 werr = WERR_ACCESS_DENIED;
                 goto err_out;
@@ -2634 +2463 @@
 ssize_t print_job_write(struct tevent_context *ev,
                         struct messaging_context *msg_ctx,
-                        int snum, uint32 jobid, const char *buf, size_t size)
+                        int snum, uint32_t jobid, const char *buf, size_t size)
 {
         const char* sharename = lp_const_servicename(snum);
@@ -2651 +2480 @@
 
         /* don't allow another process to get this info - it is meaningless */
-        if (pjob->pid != sys_getpid()) {
+        if (pjob->pid != getpid()) {
                 return_code = -1;
                 goto err_out;
@@ -2738 +2567 @@
 
 static WERROR allocate_print_jobid(struct tdb_print_db *pdb, int snum,
-                                   const char *sharename, uint32 *pjobid)
+                                   const char *sharename, uint32_t *pjobid)
 {
         int i;
-        uint32 jobid;
+        uint32_t jobid;
         enum TDB_ERROR terr;
         int ret;
 
-        *pjobid = (uint32)-1;
+        *pjobid = (uint32_t)-1;
 
         for (i = 0; i < 3; i++) {
@@ -2751 +2580 @@
                 ret = tdb_lock_bystring_with_timeout(pdb->tdb,
                                                      "INFO/nextjob", 20);
-                if (ret == -1) {
+                if (ret != 0) {
                         DEBUG(0, ("allocate_print_jobid: "
                                   "Failed to lock printing database %s\n",
@@ -2779 +2608 @@
 
                 ret = tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid);
-                if (ret == -1) {
+                if (ret != 0) {
                         terr = tdb_error(pdb->tdb);
                         DEBUG(3, ("allocate_print_jobid: "
@@ -2812 +2641 @@
                 dum.dsize = 0;
                 if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dum,
-                              TDB_INSERT) == -1) {
+                              TDB_INSERT) != 0) {
                         DEBUG(3, ("allocate_print_jobid: "
                                   "jobid (%d) failed to store placeholder.\n",
@@ -2829 +2658 @@
 ***************************************************************************/
 
-static bool add_to_jobs_added(struct tdb_print_db *pdb, uint32 jobid)
+static bool add_to_jobs_added(struct tdb_print_db *pdb, uint32_t jobid)
 {
         TDB_DATA data;
-        uint32 store_jobid;
+        uint32_t store_jobid;
 
         SIVAL(&store_jobid, 0, jobid);
-        data.dptr = (uint8 *)&store_jobid;
+        data.dptr = (uint8_t *)&store_jobid;
         data.dsize = 4;
 
@@ -2849 +2678 @@
 ***************************************************************************/
 
-static WERROR print_job_checks(const struct auth_serversupplied_info *server_info,
+static WERROR print_job_checks(const struct auth_session_info *server_info,
                                struct messaging_context *msg_ctx,
                                int snum, int *njobs)
@@ -2858 +2687 @@
         int ret;
 
-        if (!print_access_check(server_info, msg_ctx, snum,
-                                PRINTER_ACCESS_USE)) {
+        if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+                                              PRINTER_ACCESS_USE))) {
                 DEBUG(3, ("print_job_checks: "
                           "job start denied by security descriptor\n"));
@@ -2872 +2701 @@
 
         /* see if we have sufficient disk space */
-        if (lp_minprintspace(snum)) {
-                minspace = lp_minprintspace(snum);
-                ret = sys_fsusage(lp_pathname(snum), &dspace, &dsize);
+        if (lp_min_print_space(snum)) {
+                minspace = lp_min_print_space(snum);
+                ret = sys_fsusage(lp_path(talloc_tos(), snum), &dspace, &dsize);
                 if (ret == 0 && dspace < 2*minspace) {
                         DEBUG(3, ("print_job_checks: "
@@ -2913 +2742 @@
         const char *path;
         int len;
+        mode_t mask;
 
         /* if this file is within the printer path, it means that smbd
@@ -2919 +2749 @@
          * already already there */
         if (output_file) {
-                path = lp_pathname(snum);
+                path = lp_path(talloc_tos(), snum);
                 len = strlen(path);
                 if (strncmp(output_file, path, len) == 0 &&
@@ -2937 +2767 @@
 
                         DEBUG(3, ("print_job_spool_file:"
-                                  "External spooling activated"));
+                                  "External spooling activated\n"));
 
                         /* we do not open the file until spooling is done */
@@ -2948 +2778 @@
 
         slprintf(pjob->filename, sizeof(pjob->filename)-1,
-                 "%s/%sXXXXXX", lp_pathname(snum), PRINT_SPOOL_PREFIX);
+                 "%s/%sXXXXXX", lp_path(talloc_tos(), snum),
+                 PRINT_SPOOL_PREFIX);
+        mask = umask(S_IRWXO | S_IRWXG);
         pjob->fd = mkstemp(pjob->filename);
+        umask(mask);
 
         if (pjob->fd == -1) {
@@ -2974 +2807 @@
 ***************************************************************************/
 
-WERROR print_job_start(const struct auth_serversupplied_info *server_info,
+WERROR print_job_start(const struct auth_session_info *server_info,
                        struct messaging_context *msg_ctx,
                        const char *clientmachine,
@@ -2992 +2825 @@
         }
 
-        path = lp_pathname(snum);
+        path = lp_path(talloc_tos(), snum);
 
         werr = print_job_checks(server_info, msg_ctx, snum, &njobs);
@@ -3013 +2846 @@
         ZERO_STRUCT(pjob);
 
-        pjob.pid = sys_getpid();
+        pjob.pid = getpid();
         pjob.jobid = jobid;
         pjob.sysjob = -1;
@@ -3029 +2862 @@
 
         fstrcpy(pjob.user, lp_printjob_username(snum));
-        standard_sub_advanced(sharename, server_info->sanitized_username,
-                              path, server_info->utok.gid,
-                              server_info->sanitized_username,
-                              server_info->info3->base.domain.string,
-                              pjob.user, sizeof(pjob.user)-1);
-        /* ensure NULL termination */
-        pjob.user[sizeof(pjob.user)-1] = '\0';
+        standard_sub_advanced(sharename, server_info->unix_info->sanitized_username,
+                              path, server_info->unix_token->gid,
+                              server_info->unix_info->sanitized_username,
+                              server_info->info->domain_name,
+                              pjob.user, sizeof(pjob.user));
 
         fstrcpy(pjob.queuename, lp_const_servicename(snum));
@@ -3075 +2906 @@
 
 void print_job_endpage(struct messaging_context *msg_ctx,
-                       int snum, uint32 jobid)
+                       int snum, uint32_t jobid)
 {
         const char* sharename = lp_const_servicename(snum);
@@ -3089 +2920 @@
         }
         /* don't allow another process to get this info - it is meaningless */
-        if (pjob->pid != sys_getpid()) {
+        if (pjob->pid != getpid()) {
                 goto err_out;
         }
@@ -3106 +2937 @@
 
 NTSTATUS print_job_end(struct messaging_context *msg_ctx, int snum,
-                       uint32 jobid, enum file_close_type close_type)
+                       uint32_t jobid, enum file_close_type close_type)
 {
         const char* sharename = lp_const_servicename(snum);
@@ -3126 +2957 @@
         }
 
-        if (pjob->spooled || pjob->pid != sys_getpid()) {
+        if (pjob->spooled || pjob->pid != getpid()) {
                 status = NT_STATUS_ACCESS_DENIED;
                 goto err_out;
@@ -3184 +3015 @@
         /* don't strip out characters like '$' from the printername */
         lpq_cmd = talloc_string_sub2(tmp_ctx,
-                                     lp_lpqcommand(snum),
+                                     lp_lpq_command(talloc_tos(), snum),
                                      "%p",
-                                     lp_printername(snum),
+                                     lp_printername(talloc_tos(), snum),
                                      false, false, false);
         if (lpq_cmd == NULL) {
@@ -3193 +3024 @@
         }
         lpq_cmd = talloc_sub_advanced(tmp_ctx,
-                                      lp_servicename(snum),
+                                      lp_servicename(talloc_tos(), snum),
                                       current_user_info.unix_name,
                                       "",
@@ -3246 +3077 @@
         TDB_DATA data, cgdata, jcdata;
         print_queue_struct *queue = NULL;
-        uint32 qcount = 0;
-        uint32 extra_count = 0;
+        uint32_t qcount = 0;
+        uint32_t extra_count = 0;
         uint32_t changed_count = 0;
         int total_count = 0;
         size_t len = 0;
-        uint32 i;
-        int max_reported_jobs = lp_max_reported_jobs(snum);
-        bool ret = False;
-        const char* sharename = lp_servicename(snum);
+        uint32_t i;
+        int max_reported_jobs = lp_max_reported_print_jobs(snum);
+        bool ret = false;
+        const char* sharename = lp_servicename(talloc_tos(), snum);
         TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
         if (tmp_ctx == NULL) {
@@ -3297 +3128 @@
         /* Retrieve the linearised queue data. */
 
-        for( i  = 0; i < qcount; i++) {
-                uint32 qjob, qsize, qpage_count, qstatus, qpriority, qtime;
+        for(i = 0; i < qcount; i++) {
+                uint32_t qjob, qsize, qpage_count, qstatus, qpriority, qtime;
                 len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
                                 &qjob,
@@ -3319 +3150 @@
 
         /* Add new jobids to the queue. */
-        for( i  = 0; i < extra_count; i++) {
-                uint32 jobid;
+        for (i = 0; i < extra_count; i++) {
+                uint32_t jobid;
                 struct printjob *pjob;
 
@@ -3332 +3163 @@
                 }
 
-                queue[total_count].sysjob = jobid;
+                queue[total_count].sysjob = pjob->sysjob;
                 queue[total_count].size = pjob->size;
                 queue[total_count].page_count = pjob->page_count;
@@ -3347 +3178 @@
         for (i = 0; i < changed_count; i++) {
                 uint32_t jobid = IVAL(jcdata.dptr, i * 4);
+                struct printjob *pjob;
                 uint32_t j;
                 bool found = false;
 
+                pjob = print_job_find(tmp_ctx, sharename, jobid);
+                if (pjob == NULL) {
+                        DEBUG(5,("get_stored_queue_info: failed to find "
+                                 "changed job = %u\n",
+                                 (unsigned int)jobid));
+                        remove_from_jobs_changed(sharename, jobid);
+                        continue;
+                }
+
                 for (j = 0; j < total_count; j++) {
-                        if (queue[j].sysjob == jobid) {
+                        if (queue[j].sysjob == pjob->sysjob) {
                                 found = true;
                                 break;
@@ -3358 +3199 @@
 
                 if (found) {
-                        struct printjob *pjob;
-
                         DEBUG(5,("get_stored_queue_info: changed job: %u\n",
-                                 (unsigned int) jobid));
-
-                        pjob = print_job_find(tmp_ctx, sharename, jobid);
-                        if (pjob == NULL) {
-                                DEBUG(5,("get_stored_queue_info: failed to find "
-                                         "changed job = %u\n",
-                                         (unsigned int) jobid));
-                                remove_from_jobs_changed(sharename, jobid);
-                                continue;
-                        }
-
-                        queue[j].sysjob = jobid;
+                                 (unsigned int)jobid));
+
+                        queue[j].sysjob = pjob->sysjob;
                         queue[j].size = pjob->size;
                         queue[j].page_count = pjob->page_count;
@@ -3382 +3212 @@
                         talloc_free(pjob);
 
-                        DEBUG(5,("get_stored_queue_info: updated queue[%u], jobid: %u, jobname: %s\n",
-                                 (unsigned int) j, (unsigned int) jobid, pjob->jobname));
+                        DEBUG(5,("updated queue[%u], jobid: %u, sysjob: %u, "
+                                 "jobname: %s\n",
+                                 (unsigned int)j, (unsigned int)jobid,
+                                 (unsigned int)queue[j].sysjob, pjob->jobname));
                 }
 
@@ -3402 +3234 @@
         *pcount = total_count;
 
-        ret = True;
+        ret = true;
 
   out:
@@ -3480 +3312 @@
 ****************************************************************************/
 
-WERROR print_queue_pause(const struct auth_serversupplied_info *server_info,
+WERROR print_queue_pause(const struct auth_session_info *server_info,
                          struct messaging_context *msg_ctx, int snum)
 {
@@ -3486 +3318 @@
         struct printif *current_printif = get_printer_fns( snum );
 
-        if (!print_access_check(server_info, msg_ctx, snum,
-                                PRINTER_ACCESS_ADMINISTER)) {
+        if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+                                              PRINTER_ACCESS_ADMINISTER))) {
                 return WERR_ACCESS_DENIED;
         }
@@ -3517 +3349 @@
 ****************************************************************************/
 
-WERROR print_queue_resume(const struct auth_serversupplied_info *server_info,
+WERROR print_queue_resume(const struct auth_session_info *server_info,
                           struct messaging_context *msg_ctx, int snum)
 {
@@ -3523 +3355 @@
         struct printif *current_printif = get_printer_fns( snum );
 
-        if (!print_access_check(server_info, msg_ctx, snum,
-                                PRINTER_ACCESS_ADMINISTER)) {
+        if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum,
+                                              PRINTER_ACCESS_ADMINISTER))) {
                 return WERR_ACCESS_DENIED;
         }
@@ -3554 +3386 @@
 ****************************************************************************/
 
-WERROR print_queue_purge(const struct auth_serversupplied_info *server_info,
+WERROR print_queue_purge(const struct auth_session_info *server_info,
                          struct messaging_context *msg_ctx, int snum)
 {
@@ -3565 +3397 @@
         print_queue_update(msg_ctx, snum, True);
 
-        can_job_admin = print_access_check(server_info,
-                                           msg_ctx,
-                                           snum,
-                                           JOB_ACCESS_ADMINISTER);
+        can_job_admin = W_ERROR_IS_OK(print_access_check(server_info,
+                                                         msg_ctx,
+                                                         snum,
+                                                        JOB_ACCESS_ADMINISTER));
         njobs = print_queue_status(msg_ctx, snum, &queue, &status);
 
@@ -3574 +3406 @@
                 become_root();
 
-        for (i=0;i<njobs;i++) {
-                bool owner = is_owner(server_info, lp_const_servicename(snum),
-                                      queue[i].sysjob);
+        for (i = 0; i < njobs; i++) {
+                struct tdb_print_db *pdb;
+                int jobid;
+                bool owner;
+                pdb = get_print_db_byname(lp_const_servicename(snum));
+                if (pdb == NULL) {
+                        DEBUG(1, ("failed to find printdb for %s\n",
+                                  lp_const_servicename(snum)));
+                        continue;
+                }
+                jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob);
+                if (jobid == (uint32_t)-1) {
+                        DEBUG(2, ("jobid for system job %d not found\n",
+                                  queue[i].sysjob));
+                        continue;       /* unix job */
+                }
+                owner = is_owner(server_info, lp_const_servicename(snum),
+                                 jobid);
 
                 if (owner || can_job_admin) {
                         print_job_delete1(server_event_context(), msg_ctx,
-                                          snum, queue[i].sysjob);
+                                          snum, jobid);
                 }
         }

vendor/current/source3/printing/printing_db.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "system/passwd.h" /* uid_wrapper */
 #include "system/filesys.h"
 #include "printing.h"
@@ -38 +39 @@
         char *printdb_path = NULL;
         bool done_become_root = False;
+        char *print_cache_path;
+        int ret;
 
         SMB_ASSERT(printername != NULL);
@@ -65 +68 @@
                                 continue;
                         if (p->tdb) {
-                                if (tdb_close(print_db_head->tdb)) {
+                                if (tdb_close(p->tdb)) {
                                         DEBUG(0,("get_print_db: Failed to close tdb for printer %s\n",
-                                                                print_db_head->printer_name ));
+                                                                p->printer_name ));
                                         return NULL;
                                 }
@@ -93 +96 @@
         }
 
-        if (asprintf(&printdb_path, "%s%s.tdb",
-                                cache_path("printing/"),
-                                printername) < 0) {
+        print_cache_path = cache_path("printing/");
+        if (print_cache_path == NULL) {
+                DLIST_REMOVE(print_db_head, p);
+                SAFE_FREE(p);
+                return NULL;
+        }
+        ret = asprintf(&printdb_path, "%s%s.tdb",
+                       print_cache_path, printername);
+        TALLOC_FREE(print_cache_path);
+        if (ret < 0) {
                 DLIST_REMOVE(print_db_head, p);
                 SAFE_FREE(p);
@@ -161 +171 @@
 ****************************************************************************/
 
-struct TDB_DATA get_printer_notify_pid_list(struct tdb_context *tdb, const char *printer_name, bool cleanlist)
+TDB_DATA get_printer_notify_pid_list(struct tdb_context *tdb, const char *printer_name, bool cleanlist)
 {
         TDB_DATA data;
@@ -193 +203 @@
                 pid_t pid = (pid_t)IVAL(data.dptr, i);
 
-                if (pid == sys_getpid())
+                if (pid == getpid())
                         continue;
 

vendor/current/source3/printing/printspoolss.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
 #include "printing.h"
 #include "rpc_client/rpc_client.h"
@@ -26 +27 @@
 #include "../libcli/security/security.h"
 
+struct print_file_data {
+        char *svcname;
+        char *docname;
+        char *filename;
+        struct policy_handle handle;
+        uint32_t jobid;
+        uint16_t rap_jobid;
+};
+
+uint16_t print_spool_rap_jobid(struct print_file_data *print_file)
+{
+        if (print_file == NULL) {
+                return 0;
+        }
+
+        return print_file->rap_jobid;
+}
+
 void print_spool_terminate(struct connection_struct *conn,
                            struct print_file_data *print_file);
@@ -40 +59 @@
 NTSTATUS print_spool_open(files_struct *fsp,
                           const char *fname,
-                          uint16_t current_vuid)
+                          uint64_t current_vuid)
 {
         NTSTATUS status;
@@ -47 +66 @@
         struct dcerpc_binding_handle *b = NULL;
         struct spoolss_DevmodeContainer devmode_ctr;
-        union spoolss_DocumentInfo info;
+        struct spoolss_DocumentInfoCtr info_ctr;
+        struct spoolss_DocumentInfo1 *info1;
         int fd = -1;
         WERROR werr;
+        mode_t mask;
 
         tmp_ctx = talloc_new(fsp);
@@ -61 +82 @@
                 goto done;
         }
-        pf->svcname = talloc_strdup(pf, lp_servicename(SNUM(fsp->conn)));
+        pf->svcname = lp_servicename(pf, SNUM(fsp->conn));
 
         /* the document name is derived from the file name.
@@ -101 +122 @@
 
         pf->filename = talloc_asprintf(pf, "%s/%sXXXXXX",
-                                        lp_pathname(SNUM(fsp->conn)),
+                                        lp_path(talloc_tos(),
+                                                SNUM(fsp->conn)),
                                         PRINT_SPOOL_PREFIX);
         if (!pf->filename) {
@@ -108 +130 @@
         }
         errno = 0;
+        mask = umask(S_IRWXO | S_IRWXG);
         fd = mkstemp(pf->filename);
+        umask(mask);
         if (fd == -1) {
                 if (errno == EACCES) {
@@ -131 +155 @@
 
         status = rpc_pipe_open_interface(fsp->conn,
-                                         &ndr_table_spoolss.syntax_id,
+                                         &ndr_table_spoolss,
                                          fsp->conn->session_info,
-                                         &fsp->conn->sconn->client_id,
+                                         fsp->conn->sconn->remote_address,
                                          fsp->conn->sconn->msg_ctx,
                                          &fsp->conn->spoolss_pipe);
@@ -155 +179 @@
         }
 
-        info.info1 = talloc(tmp_ctx, struct spoolss_DocumentInfo1);
-        if (!info.info1) {
-                status = NT_STATUS_NO_MEMORY;
-                goto done;
-        }
-        info.info1->document_name = pf->docname;
-        info.info1->output_file = pf->filename;
-        info.info1->datatype = "RAW";
-
-        status = dcerpc_spoolss_StartDocPrinter(b, tmp_ctx, &pf->handle,
-                                                1, info, &pf->jobid, &werr);
+        info1 = talloc(tmp_ctx, struct spoolss_DocumentInfo1);
+        if (info1 == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        info1->document_name = pf->docname;
+        info1->output_file = pf->filename;
+        info1->datatype = "RAW";
+
+        info_ctr.level = 1;
+        info_ctr.info.info1 = info1;
+
+        status = dcerpc_spoolss_StartDocPrinter(b, tmp_ctx,
+                                                &pf->handle,
+                                                &info_ctr,
+                                                &pf->jobid,
+                                                &werr);
         if (!NT_STATUS_IS_OK(status)) {
                 goto done;
@@ -183 +213 @@
 
         /* setup a full fsp */
-        status = create_synthetic_smb_fname(fsp, pf->filename, NULL,
-                                            NULL, &fsp->fsp_name);
-        if (!NT_STATUS_IS_OK(status)) {
+        fsp->fsp_name = synthetic_smb_fname(fsp, pf->filename, NULL, NULL);
+        if (fsp->fsp_name == NULL) {
+                status = NT_STATUS_NO_MEMORY;
                 goto done;
         }
@@ -195 +225 @@
 
         fsp->file_id = vfs_file_id_from_sbuf(fsp->conn, &fsp->fsp_name->st);
-        fsp->mode = fsp->fsp_name->st.st_ex_mode;
         fsp->fh->fd = fd;
 
@@ -220 +249 @@
                 }
                 /* We need to delete the job from spoolss too */
-                if (pf->jobid) {
+                if (pf && pf->jobid) {
                         print_spool_terminate(fsp->conn, pf);
                 }
@@ -230 +259 @@
 int print_spool_write(files_struct *fsp,
                       const char *data, uint32_t size,
-                      SMB_OFF_T offset, uint32_t *written)
+                      off_t offset, uint32_t *written)
 {
         SMB_STRUCT_STAT st;
@@ -315 +344 @@
 
         status = rpc_pipe_open_interface(conn,
-                                         &ndr_table_spoolss.syntax_id,
+                                         &ndr_table_spoolss,
                                          conn->session_info,
-                                         &conn->sconn->client_id,
+                                         conn->sconn->remote_address,
                                          conn->sconn->msg_ctx,
                                          &conn->spoolss_pipe);

vendor/current/source3/printing/spoolssd.c

@@ -2 +2 @@
    Unix SMB/Netbios implementation.
    SPOOLSS Daemon
-   Copyright (C) Simo Sorce 2010
+   Copyright (C) Simo Sorce <idra@samba.org> 2010-2011
 
    This program is free software; you can redistribute it and/or modify
@@ -24 +24 @@
 #include "include/printing.h"
 #include "printing/nt_printing_migrate_internal.h"
+#include "printing/queue_process.h"
+#include "printing/pcap.h"
+#include "printing/load.h"
 #include "ntdomain.h"
 #include "librpc/gen_ndr/srv_winreg.h"
 #include "librpc/gen_ndr/srv_spoolss.h"
 #include "rpc_server/rpc_server.h"
-#include "rpc_server/rpc_ep_setup.h"
+#include "rpc_server/rpc_ep_register.h"
+#include "rpc_server/rpc_config.h"
 #include "rpc_server/spoolss/srv_spoolss_nt.h"
+#include "librpc/rpc/dcerpc_ep.h"
+#include "lib/server_prefork.h"
+#include "lib/server_prefork_util.h"
 
 #define SPOOLSS_PIPE_NAME "spoolss"
 #define DAEMON_NAME "spoolssd"
 
-void start_spoolssd(struct tevent_context *ev_ctx,
-                    struct messaging_context *msg_ctx);
-
-static void spoolss_reopen_logs(void)
-{
-        char *lfile = lp_logfile();
+static struct server_id parent_id;
+static struct prefork_pool *spoolss_pool = NULL;
+static int spoolss_child_id = 0;
+
+static struct pf_daemon_config default_pf_spoolss_cfg = {
+        .prefork_status = PFH_INIT,
+        .min_children = 5,
+        .max_children = 25,
+        .spawn_rate = 5,
+        .max_allowed_clients = 100,
+        .child_min_life = 60 /* 1 minute minimum life time */
+};
+static struct pf_daemon_config pf_spoolss_cfg = { 0 };
+
+pid_t start_spoolssd(struct tevent_context *ev_ctx,
+                     struct messaging_context *msg_ctx);
+
+static void spoolss_reopen_logs(int child_id)
+{
+        char *lfile = lp_logfile(talloc_tos());
+        char *ext;
         int rc;
 
+        if (child_id) {
+                rc = asprintf(&ext, "%s.%d", DAEMON_NAME, child_id);
+        } else {
+                rc = asprintf(&ext, "%s", DAEMON_NAME);
+        }
+
+        if (rc == -1) {
+                return;
+        }
+
+        rc = 0;
         if (lfile == NULL || lfile[0] == '\0') {
-                rc = asprintf(&lfile, "%s/log.%s", get_dyn_LOGFILEBASE(), DAEMON_NAME);
-                if (rc > 0) {
-                        lp_set_logfile(lfile);
-                        SAFE_FREE(lfile);
-                }
+                rc = asprintf(&lfile, "%s/log.%s",
+                              get_dyn_LOGFILEBASE(), ext);
         } else {
-                if (strstr(lfile, DAEMON_NAME) == NULL) {
-                        rc = asprintf(&lfile, "%s.%s", lp_logfile(), DAEMON_NAME);
-                        if (rc > 0) {
-                                lp_set_logfile(lfile);
-                                SAFE_FREE(lfile);
+                if (strstr(lfile, ext) == NULL) {
+                        if (child_id) {
+                                rc = asprintf(&lfile, "%s.%d",
+                                              lp_logfile(talloc_tos()),
+                                              child_id);
+                        } else {
+                                rc = asprintf(&lfile, "%s.%s",
+                                              lp_logfile(talloc_tos()),
+                                              ext);
                         }
                 }
         }
 
+        if (rc > 0) {
+                lp_set_logfile(lfile);
+                SAFE_FREE(lfile);
+        }
+
+        SAFE_FREE(ext);
+
         reopen_logs();
+}
+
+static void update_conf(struct tevent_context *ev,
+                        struct messaging_context *msg)
+{
+        change_to_root_user();
+        lp_load_global(get_dyn_CONFIGFILE());
+        load_printers(ev, msg);
+
+        spoolss_reopen_logs(spoolss_child_id);
+        if (spoolss_child_id == 0) {
+                pfh_daemon_config(DAEMON_NAME,
+                                  &pf_spoolss_cfg,
+                                  &default_pf_spoolss_cfg);
+                pfh_manage_pool(ev, msg, &pf_spoolss_cfg, spoolss_pool);
+        }
 }
 
@@ -71 +128 @@
 
         DEBUG(10, ("Got message saying smb.conf was updated. Reloading.\n"));
-        change_to_root_user();
-        spoolss_reopen_logs();
-}
-
-static void spoolss_pcap_updated(struct messaging_context *msg,
-                                 void *private_data,
-                                 uint32_t msg_type,
-                                 struct server_id server_id,
-                                 DATA_BLOB *data)
-{
-        struct tevent_context *ev_ctx = talloc_get_type_abort(private_data,
-                                                             struct tevent_context);
-
-        DEBUG(10, ("Got message saying pcap was updated. Reloading.\n"));
-        change_to_root_user();
-        reload_printers(ev_ctx, msg);
+        update_conf(ev_ctx, msg);
 }
 
@@ -118 +160 @@
                                     int count,
                                     void *siginfo,
-                                    void *private_data)
-{
-        struct messaging_context *msg_ctx = talloc_get_type_abort(private_data,
-                                                                  struct messaging_context);
-
-        change_to_root_user();
+                                    void *pvt)
+{
+        struct messaging_context *msg_ctx;
+
+        msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
+
         DEBUG(1,("Reloading printers after SIGHUP\n"));
-        spoolss_reopen_logs();
+        update_conf(ev, msg_ctx);
+
+        /* relay to all children */
+        if (spoolss_pool) {
+                prefork_send_signal_to_all(spoolss_pool, SIGHUP);
+        }
 }
 
@@ -158 +205 @@
 }
 
-void start_spoolssd(struct tevent_context *ev_ctx,
-                    struct messaging_context *msg_ctx)
-{
+/* Children */
+
+static void spoolss_chld_sig_hup_handler(struct tevent_context *ev,
+                                         struct tevent_signal *se,
+                                         int signum,
+                                         int count,
+                                         void *siginfo,
+                                         void *pvt)
+{
+        struct messaging_context *msg_ctx;
+
+        msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
+
+        change_to_root_user();
+        DEBUG(1,("Reloading printers after SIGHUP\n"));
+        load_printers(ev, msg_ctx);
+        spoolss_reopen_logs(spoolss_child_id);
+}
+
+static bool spoolss_setup_chld_hup_handler(struct tevent_context *ev_ctx,
+                                           struct messaging_context *msg_ctx,
+                                           struct pf_worker_data *pf)
+{
+        struct tevent_signal *se;
+
+        se = tevent_add_signal(ev_ctx,
+                               ev_ctx,
+                               SIGHUP, 0,
+                               spoolss_chld_sig_hup_handler,
+                               msg_ctx);
+        if (!se) {
+                DEBUG(1, ("failed to setup SIGHUP handler"));
+                return false;
+        }
+
+        return true;
+}
+
+static void parent_ping(struct messaging_context *msg_ctx,
+                        void *private_data,
+                        uint32_t msg_type,
+                        struct server_id server_id,
+                        DATA_BLOB *data)
+{
+
+        /* The fact we received this message is enough to let make the event
+         * loop if it was idle. spoolss_children_main will cycle through
+         * spoolss_next_client at least once. That function will take whatever
+         * action is necessary */
+
+        DEBUG(10, ("Got message that the parent changed status.\n"));
+        return;
+}
+
+static bool spoolss_child_init(struct tevent_context *ev_ctx,
+                               int child_id, struct pf_worker_data *pf)
+{
+        NTSTATUS status;
         struct rpc_srv_callbacks spoolss_cb;
-        pid_t pid;
-        NTSTATUS status;
-        int ret;
-
-        DEBUG(1, ("Forking SPOOLSS Daemon\n"));
-
-        pid = sys_fork();
-
-        if (pid == -1) {
-                DEBUG(0, ("Failed to fork SPOOLSS [%s], aborting ...\n",
-                           strerror(errno)));
-                exit(1);
-        }
-
-        if (pid) {
-                /* parent */
-                return;
-        }
-
-        /* child */
-        close_low_fds(false);
-
-        status = reinit_after_fork(msg_ctx,
-                                   ev_ctx,
-                                   procid_self(), true);
+        struct messaging_context *msg_ctx = server_messaging_context();
+        bool ok;
+
+        status = reinit_after_fork(msg_ctx, ev_ctx, true, "spoolssd-child");
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("reinit_after_fork() failed\n"));
@@ -192 +273 @@
         }
 
-        spoolss_reopen_logs();
-
-        spoolss_setup_sig_term_handler(ev_ctx);
-        spoolss_setup_sig_hup_handler(ev_ctx, msg_ctx);
-
-        if (!serverid_register(procid_self(),
-                                FLAG_MSG_GENERAL|FLAG_MSG_SMBD
-                                |FLAG_MSG_PRINT_GENERAL)) {
-                exit(1);
+        spoolss_child_id = child_id;
+        spoolss_reopen_logs(child_id);
+
+        ok = spoolss_setup_chld_hup_handler(ev_ctx, msg_ctx, pf);
+        if (!ok) {
+                return false;
+        }
+
+        if (!serverid_register(messaging_server_id(msg_ctx),
+                                FLAG_MSG_GENERAL |
+                                FLAG_MSG_PRINT_GENERAL)) {
+                return false;
         }
 
         if (!locking_init()) {
-                exit(1);
-        }
-
-        messaging_register(msg_ctx, NULL,
-                           MSG_PRINTER_UPDATE, print_queue_receive);
+                return false;
+        }
+
         messaging_register(msg_ctx, ev_ctx,
                            MSG_SMB_CONF_UPDATED, smb_conf_updated);
         messaging_register(msg_ctx, ev_ctx,
-                           MSG_PRINTER_PCAP, spoolss_pcap_updated);
+                           MSG_PREFORK_PARENT_EVENT, parent_ping);
+
+        /* As soon as messaging is up check if pcap has been loaded already.
+         * If so then we probably missed a message and should load_printers()
+         * ourselves. If pcap has not been loaded yet, then ignore, we will get
+         * a message as soon as the bq process completes the reload. */
+        if (pcap_cache_loaded(NULL)) {
+                load_printers(ev_ctx, msg_ctx);
+        }
+
+        /* try to reinit rpc queues */
+        spoolss_cb.init = spoolss_init_cb;
+        spoolss_cb.shutdown = spoolss_shutdown_cb;
+        spoolss_cb.private_data = msg_ctx;
+
+        status = rpc_winreg_init(NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("Failed to register winreg rpc interface! (%s)\n",
+                          nt_errstr(status)));
+                return false;
+        }
+
+        status = rpc_spoolss_init(&spoolss_cb);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("Failed to register spoolss rpc interface! (%s)\n",
+                          nt_errstr(status)));
+                return false;
+        }
+
+        return true;
+}
+
+struct spoolss_children_data {
+        struct tevent_context *ev_ctx;
+        struct messaging_context *msg_ctx;
+        struct pf_worker_data *pf;
+        int listen_fd_size;
+        int *listen_fds;
+};
+
+static void spoolss_next_client(void *pvt);
+
+static int spoolss_children_main(struct tevent_context *ev_ctx,
+                                 struct messaging_context *msg_ctx,
+                                 struct pf_worker_data *pf,
+                                 int child_id,
+                                 int listen_fd_size,
+                                 int *listen_fds,
+                                 void *private_data)
+{
+        struct spoolss_children_data *data;
+        bool ok;
+        int ret = 0;
+
+        ok = spoolss_child_init(ev_ctx, child_id, pf);
+        if (!ok) {
+                return 1;
+        }
+
+        data = talloc(ev_ctx, struct spoolss_children_data);
+        if (!data) {
+                return 1;
+        }
+        data->pf = pf;
+        data->ev_ctx = ev_ctx;
+        data->msg_ctx = msg_ctx;
+        data->listen_fd_size = listen_fd_size;
+        data->listen_fds = listen_fds;
+
+        /* loop until it is time to exit */
+        while (pf->status != PF_WORKER_EXITING) {
+                /* try to see if it is time to schedule the next client */
+                spoolss_next_client(data);
+
+                ret = tevent_loop_once(ev_ctx);
+                if (ret != 0) {
+                        DEBUG(0, ("tevent_loop_once() exited with %d: %s\n",
+                                  ret, strerror(errno)));
+                        pf->status = PF_WORKER_EXITING;
+                }
+        }
+
+        return ret;
+}
+
+static void spoolss_client_terminated(void *pvt)
+{
+        struct spoolss_children_data *data;
+
+        data = talloc_get_type_abort(pvt, struct spoolss_children_data);
+
+        pfh_client_terminated(data->pf);
+
+        spoolss_next_client(pvt);
+}
+
+struct spoolss_new_client {
+        struct spoolss_children_data *data;
+        struct tsocket_address *srv_addr;
+        struct tsocket_address *cli_addr;
+};
+
+static void spoolss_handle_client(struct tevent_req *req);
+
+static void spoolss_next_client(void *pvt)
+{
+        struct tevent_req *req;
+        struct spoolss_children_data *data;
+        struct spoolss_new_client *next;
+
+        data = talloc_get_type_abort(pvt, struct spoolss_children_data);
+
+        if (!pfh_child_allowed_to_accept(data->pf)) {
+                /* nothing to do for now we are already listening
+                 * or we are not allowed to listen further */
+                return;
+        }
+
+        next = talloc_zero(data, struct spoolss_new_client);
+        if (!next) {
+                DEBUG(1, ("Out of memory!?\n"));
+                return;
+        }
+        next->data = data;
+
+        req = prefork_listen_send(next, data->ev_ctx, data->pf,
+                                  data->listen_fd_size,
+                                  data->listen_fds);
+        if (!req) {
+                DEBUG(1, ("Failed to make listening request!?\n"));
+                talloc_free(next);
+                return;
+        }
+        tevent_req_set_callback(req, spoolss_handle_client, next);
+}
+
+static void spoolss_handle_client(struct tevent_req *req)
+{
+        struct spoolss_children_data *data;
+        struct spoolss_new_client *client;
+        const DATA_BLOB ping = data_blob_null;
+        int ret;
+        int sd;
+
+        client = tevent_req_callback_data(req, struct spoolss_new_client);
+        data = client->data;
+
+        ret = prefork_listen_recv(req, client, &sd,
+                                  &client->srv_addr, &client->cli_addr);
+
+        /* this will free the request too */
+        talloc_free(client);
+
+        if (ret != 0) {
+                DEBUG(6, ("No client connection was available after all!\n"));
+                return;
+        }
+
+        /* Warn parent that our status changed */
+        messaging_send(data->msg_ctx, parent_id,
+                        MSG_PREFORK_CHILD_EVENT, &ping);
+
+        DEBUG(2, ("Spoolss preforked child %d got client connection!\n",
+                  (int)(data->pf->pid)));
+
+        named_pipe_accept_function(data->ev_ctx, data->msg_ctx,
+                                   SPOOLSS_PIPE_NAME, sd,
+                                   spoolss_client_terminated, data);
+}
+
+/* ==== Main Process Functions ==== */
+
+extern pid_t background_lpq_updater_pid;
+static char *bq_logfile;
+
+static void check_updater_child(struct tevent_context *ev_ctx,
+                                struct messaging_context *msg_ctx)
+{
+        int status;
+        pid_t pid;
+
+        if (background_lpq_updater_pid == -1) {
+                return;
+        }
+
+        pid = sys_waitpid(background_lpq_updater_pid, &status, WNOHANG);
+        if (pid > 0) {
+                DEBUG(2, ("The background queue child died... Restarting!\n"));
+                pid = start_background_queue(ev_ctx, msg_ctx, bq_logfile);
+                background_lpq_updater_pid = pid;
+        }
+}
+
+static void child_ping(struct messaging_context *msg_ctx,
+                        void *private_data,
+                        uint32_t msg_type,
+                        struct server_id server_id,
+                        DATA_BLOB *data)
+{
+        struct tevent_context *ev_ctx;
+
+        ev_ctx = talloc_get_type_abort(private_data, struct tevent_context);
+
+        DEBUG(10, ("Got message that a child changed status.\n"));
+        pfh_manage_pool(ev_ctx, msg_ctx, &pf_spoolss_cfg, spoolss_pool);
+}
+
+static bool spoolssd_schedule_check(struct tevent_context *ev_ctx,
+                                    struct messaging_context *msg_ctx,
+                                    struct timeval current_time);
+static void spoolssd_check_children(struct tevent_context *ev_ctx,
+                                    struct tevent_timer *te,
+                                    struct timeval current_time,
+                                    void *pvt);
+
+static void spoolssd_sigchld_handler(struct tevent_context *ev_ctx,
+                                     struct prefork_pool *pfp,
+                                     void *pvt)
+{
+        struct messaging_context *msg_ctx;
+
+        msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
+
+        /* run pool management so we can fork/retire or increase
+         * the allowed connections per child based on load */
+        pfh_manage_pool(ev_ctx, msg_ctx, &pf_spoolss_cfg, spoolss_pool);
+
+        /* also check if the updater child is alive and well */
+        check_updater_child(ev_ctx, msg_ctx);
+}
+
+static bool spoolssd_setup_children_monitor(struct tevent_context *ev_ctx,
+                                            struct messaging_context *msg_ctx)
+{
+        bool ok;
+
+        /* add our oun sigchld callback */
+        prefork_set_sigchld_callback(spoolss_pool,
+                                     spoolssd_sigchld_handler, msg_ctx);
+
+        ok = spoolssd_schedule_check(ev_ctx, msg_ctx,
+                                     tevent_timeval_current());
+        return ok;
+}
+
+static bool spoolssd_schedule_check(struct tevent_context *ev_ctx,
+                                    struct messaging_context *msg_ctx,
+                                    struct timeval current_time)
+{
+        struct tevent_timer *te;
+        struct timeval next_event;
+
+        /* check situation again in 10 seconds */
+        next_event = tevent_timeval_current_ofs(10, 0);
+
+        /* TODO: check when the socket becomes readable, so that children
+         * are checked only when there is some activity ? */
+        te = tevent_add_timer(ev_ctx, spoolss_pool, next_event,
+                                spoolssd_check_children, msg_ctx);
+        if (!te) {
+                DEBUG(2, ("Failed to set up children monitoring!\n"));
+                return false;
+        }
+
+        return true;
+}
+
+static void spoolssd_check_children(struct tevent_context *ev_ctx,
+                                    struct tevent_timer *te,
+                                    struct timeval current_time,
+                                    void *pvt)
+{
+        struct messaging_context *msg_ctx;
+
+        msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
+
+        pfh_manage_pool(ev_ctx, msg_ctx, &pf_spoolss_cfg, spoolss_pool);
+
+        spoolssd_schedule_check(ev_ctx, msg_ctx, current_time);
+}
+
+static void print_queue_forward(struct messaging_context *msg,
+                                void *private_data,
+                                uint32_t msg_type,
+                                struct server_id server_id,
+                                DATA_BLOB *data)
+{
+        messaging_send_buf(msg, pid_to_procid(background_lpq_updater_pid),
+                           MSG_PRINTER_UPDATE, data->data, data->length);
+}
+
+static char *get_bq_logfile(void)
+{
+        char *lfile = lp_logfile(talloc_tos());
+        int rc;
+
+        if (lfile == NULL || lfile[0] == '\0') {
+                rc = asprintf(&lfile, "%s/log.%s.bq",
+                                        get_dyn_LOGFILEBASE(), DAEMON_NAME);
+        } else {
+                rc = asprintf(&lfile, "%s.bq", lp_logfile(talloc_tos()));
+        }
+        if (rc == -1) {
+                lfile = NULL;
+        }
+        return lfile;
+}
+
+pid_t start_spoolssd(struct tevent_context *ev_ctx,
+                    struct messaging_context *msg_ctx)
+{
+        enum rpc_service_mode_e epm_mode = rpc_epmapper_mode();
+        struct rpc_srv_callbacks spoolss_cb;
+        struct dcerpc_binding_vector *v;
+        TALLOC_CTX *mem_ctx;
+        pid_t pid;
+        NTSTATUS status;
+        int listen_fd;
+        int ret;
+        bool ok;
+
+        DEBUG(1, ("Forking SPOOLSS Daemon\n"));
+
+        /*
+         * Block signals before forking child as it will have to
+         * set its own handlers. Child will re-enable SIGHUP as
+         * soon as the handlers are set up.
+         */
+        BlockSignals(true, SIGTERM);
+        BlockSignals(true, SIGHUP);
+
+        pid = fork();
+
+        if (pid == -1) {
+                DEBUG(0, ("Failed to fork SPOOLSS [%s]\n",
+                           strerror(errno)));
+        }
+
+        /* parent or error */
+        if (pid != 0) {
+
+                /* Re-enable SIGHUP before returnig */
+                BlockSignals(false, SIGTERM);
+                BlockSignals(false, SIGHUP);
+                return pid;
+        }
+
+        status = smbd_reinit_after_fork(msg_ctx, ev_ctx, true,
+                                        "spoolssd-master");
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,("reinit_after_fork() failed\n"));
+                smb_panic("reinit_after_fork() failed");
+        }
+
+        /* save the parent process id so the children can use it later */
+        parent_id = messaging_server_id(msg_ctx);
+
+        spoolss_reopen_logs(0);
+        pfh_daemon_config(DAEMON_NAME,
+                          &pf_spoolss_cfg,
+                          &default_pf_spoolss_cfg);
+
+        spoolss_setup_sig_term_handler(ev_ctx);
+        spoolss_setup_sig_hup_handler(ev_ctx, msg_ctx);
+
+        BlockSignals(false, SIGTERM);
+        BlockSignals(false, SIGHUP);
+
+        /* always start the backgroundqueue listner in spoolssd */
+        bq_logfile = get_bq_logfile();
+        pid = start_background_queue(ev_ctx, msg_ctx, bq_logfile);
+        if (pid > 0) {
+                background_lpq_updater_pid = pid;
+        }
+
+        /* the listening fd must be created before the children are actually
+         * forked out. */
+        listen_fd = create_named_pipe_socket(SPOOLSS_PIPE_NAME);
+        if (listen_fd == -1) {
+                exit(1);
+        }
+
+        ret = listen(listen_fd, pf_spoolss_cfg.max_allowed_clients);
+        if (ret == -1) {
+                DEBUG(0, ("Failed to listen on spoolss pipe - %s\n",
+                          strerror(errno)));
+                exit(1);
+        }
+
+        /* start children before any more initialization is done */
+        ok = prefork_create_pool(ev_ctx, /* mem_ctx */
+                                 ev_ctx, msg_ctx,
+                                 1, &listen_fd,
+                                 pf_spoolss_cfg.min_children,
+                                 pf_spoolss_cfg.max_children,
+                                 &spoolss_children_main, NULL,
+                                 &spoolss_pool);
+        if (!ok) {
+                exit(1);
+        }
+
+        if (!serverid_register(messaging_server_id(msg_ctx),
+                                FLAG_MSG_GENERAL |
+                                FLAG_MSG_PRINT_GENERAL)) {
+                exit(1);
+        }
+
+        if (!locking_init()) {
+                exit(1);
+        }
+
+        messaging_register(msg_ctx, ev_ctx,
+                           MSG_SMB_CONF_UPDATED, smb_conf_updated);
+        messaging_register(msg_ctx, NULL, MSG_PRINTER_UPDATE,
+                           print_queue_forward);
+        messaging_register(msg_ctx, ev_ctx,
+                           MSG_PREFORK_CHILD_EVENT, child_ping);
+
+        /*
+         * As soon as messaging is up check if pcap has been loaded already.
+         * If pcap has not been loaded yet, then ignore, as we will reload on
+         * client enumeration anyway.
+         */
+        if (pcap_cache_loaded(NULL)) {
+                load_printers(ev_ctx, msg_ctx);
+        }
+
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                exit(1);
+        }
 
         /*
@@ -225 +737 @@
         status = rpc_winreg_init(NULL);
         if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0, ("Failed to register winreg rpc inteface! (%s)\n",
+                DEBUG(0, ("Failed to register winreg rpc interface! (%s)\n",
                           nt_errstr(status)));
                 exit(1);
@@ -232 +744 @@
         status = rpc_spoolss_init(&spoolss_cb);
         if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0, ("Failed to register spoolss rpc inteface! (%s)\n",
+                DEBUG(0, ("Failed to register spoolss rpc interface! (%s)\n",
                           nt_errstr(status)));
                 exit(1);
         }
 
-        if (!setup_named_pipe_socket(SPOOLSS_PIPE_NAME, ev_ctx)) {
-                exit(1);
-        }
-
-        status = rpc_ep_setup_register(ev_ctx, msg_ctx, &ndr_table_spoolss, NULL, 0);
-        if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0, ("Failed to register spoolss endpoint! (%s)\n",
-                          nt_errstr(status)));
-                exit(1);
-        }
-
-        DEBUG(1, ("SPOOLSS Daemon Started (%d)\n", getpid()));
+        if (epm_mode != RPC_SERVICE_MODE_DISABLED &&
+            (lp_parm_bool(-1, "rpc_server", "register_embedded_np", false))) {
+                status = dcerpc_binding_vector_new(mem_ctx, &v);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("Failed to create binding vector (%s)\n",
+                                  nt_errstr(status)));
+                        exit(1);
+                }
+
+                status = dcerpc_binding_vector_add_np_default(&ndr_table_spoolss, v);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("Failed to add np to binding vector (%s)\n",
+                                  nt_errstr(status)));
+                        exit(1);
+                }
+
+                status = rpc_ep_register(ev_ctx, msg_ctx, &ndr_table_spoolss, v);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("Failed to register spoolss endpoint! (%s)\n",
+                                  nt_errstr(status)));
+                        exit(1);
+                }
+        }
+
+        talloc_free(mem_ctx);
+
+        ok = spoolssd_setup_children_monitor(ev_ctx, msg_ctx);
+        if (!ok) {
+                DEBUG(0, ("Failed to setup children monitoring!\n"));
+                exit(1);
+        }
+
+        DEBUG(1, ("SPOOLSS Daemon Started (%u)\n", (unsigned int)getpid()));
+
+        pfh_manage_pool(ev_ctx, msg_ctx, &pf_spoolss_cfg, spoolss_pool);
 
         /* loop forever */
@@ -254 +789 @@
 
         /* should not be reached */
-        DEBUG(0,("background_queue: tevent_loop_wait() exited with %d - %s\n",
+        DEBUG(0,("spoolssd tevent_loop_wait() exited with %d - %s\n",
                  ret, (ret == 0) ? "out of events" : strerror(errno)));
         exit(1);

vendor/current/source3/printing/tests/vlp.c

@@ -112 +112 @@
 {
         fstring keystr;
-        int result;
 
         slprintf(keystr, sizeof(keystr) - 1, "STATUS/%s", printer);
-        result = tdb_store_int32(tdb, keystr, status);
+        tdb_store_int32(tdb, keystr, status);
 }
 
@@ -395 +394 @@
         }
 
+        /* FIXME: We should *never* open a tdb without logging! */
         if (!(tdb = tdb_open(printdb_path, 0, 0, O_RDWR | O_CREAT,
                              0666))) {