Changeset 862 for trunk/server/source3/printing

Timestamp:

May 13, 2014, 11:39:04 AM (11 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update trunk to 3.6.23

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source3/printing/nt_printing_ads.c (modified) (9 diffs)
• source3/printing/nt_printing_migrate.c (modified) (4 diffs)
• source3/printing/nt_printing_migrate.h (modified) (1 diff)
• source3/printing/nt_printing_migrate_internal.c (modified) (2 diffs)
• source3/printing/printing.c (modified) (6 diffs)
• source3/printing/spoolssd.c (modified) (3 diffs)

trunk/server/source3/printing/nt_printing_ads.c

@@ -88 +88 @@
 }
 
+WERROR nt_printer_guid_get(TALLOC_CTX *mem_ctx,
+                           const struct auth_serversupplied_info *session_info,
+                           struct messaging_context *msg_ctx,
+                           const char *printer, struct GUID *guid)
+{
+        TALLOC_CTX *tmp_ctx;
+        enum winreg_Type type;
+        DATA_BLOB blob;
+        uint32_t len;
+        NTSTATUS status;
+        WERROR result;
+
+        tmp_ctx = talloc_new(mem_ctx);
+        if (tmp_ctx == NULL) {
+                DEBUG(0, ("out of memory?!\n"));
+                return WERR_NOMEM;
+        }
+
+        result = winreg_get_printer_dataex_internal(tmp_ctx, session_info,
+                                                    msg_ctx, printer,
+                                                    SPOOL_DSSPOOLER_KEY,
+                                                    "objectGUID",
+                                                    &type,
+                                                    &blob.data,
+                                                    &len);
+        if (!W_ERROR_IS_OK(result)) {
+                DEBUG(0, ("Failed to get GUID for printer %s\n", printer));
+                goto out_ctx_free;
+        }
+        blob.length = (size_t)len;
+
+        /* We used to store the guid as REG_BINARY, then swapped
+           to REG_SZ for Vista compatibility so check for both */
+
+        switch (type) {
+        case REG_SZ: {
+                bool ok;
+                const char *guid_str;
+                ok = pull_reg_sz(tmp_ctx, &blob, &guid_str);
+                if (!ok) {
+                        DEBUG(0, ("Failed to unmarshall GUID for printer %s\n",
+                                  printer));
+                        result = WERR_REG_CORRUPT;
+                        goto out_ctx_free;
+                }
+                status = GUID_from_string(guid_str, guid);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("bad GUID for printer %s\n", printer));
+                        result = ntstatus_to_werror(status);
+                        goto out_ctx_free;
+                }
+                break;
+        }
+        case REG_BINARY:
+                if (blob.length != sizeof(struct GUID)) {
+                        DEBUG(0, ("bad GUID for printer %s\n", printer));
+                        result = WERR_REG_CORRUPT;
+                        goto out_ctx_free;
+                }
+                memcpy(guid, blob.data, sizeof(struct GUID));
+                break;
+        default:
+                DEBUG(0,("GUID value stored as invalid type (%d)\n", type));
+                result = WERR_REG_CORRUPT;
+                goto out_ctx_free;
+                break;
+        }
+        result = WERR_OK;
+
+out_ctx_free:
+        talloc_free(tmp_ctx);
+        return result;
+}
+
+static WERROR nt_printer_info_to_mods(TALLOC_CTX *ctx,
+                                      struct spoolss_PrinterInfo2 *info2,
+                                      ADS_MODLIST *mods)
+{
+        char *info_str;
+
+        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_SERVERNAME, get_mydnsfullname());
+
+        info_str = talloc_asprintf(ctx, "\\\\%s\\%s",
+                                   get_mydnsfullname(), info2->sharename);
+        if (info_str == NULL) {
+                return WERR_NOMEM;
+        }
+        ads_mod_str(ctx, mods, SPOOL_REG_UNCNAME, info_str);
+
+        info_str = talloc_asprintf(ctx, "%d", 4);
+        if (info_str == NULL) {
+                return WERR_NOMEM;
+        }
+        ads_mod_str(ctx, mods, SPOOL_REG_VERSIONNUMBER, info_str);
+
+        /* empty strings in the mods list result in an attrubute error */
+        if (strlen(info2->drivername) != 0)
+                ads_mod_str(ctx, mods, SPOOL_REG_DRIVERNAME, info2->drivername);
+        if (strlen(info2->location) != 0)
+                ads_mod_str(ctx, mods, SPOOL_REG_LOCATION, info2->location);
+        if (strlen(info2->comment) != 0)
+                ads_mod_str(ctx, mods, SPOOL_REG_DESCRIPTION, info2->comment);
+        if (strlen(info2->portname) != 0)
+                ads_mod_str(ctx, mods, SPOOL_REG_PORTNAME, info2->portname);
+        if (strlen(info2->sepfile) != 0)
+                ads_mod_str(ctx, mods, SPOOL_REG_PRINTSEPARATORFILE, info2->sepfile);
+
+        info_str = talloc_asprintf(ctx, "%u", info2->starttime);
+        if (info_str == NULL) {
+                return WERR_NOMEM;
+        }
+        ads_mod_str(ctx, mods, SPOOL_REG_PRINTSTARTTIME, info_str);
+
+        info_str = talloc_asprintf(ctx, "%u", info2->untiltime);
+        if (info_str == NULL) {
+                return WERR_NOMEM;
+        }
+        ads_mod_str(ctx, mods, SPOOL_REG_PRINTENDTIME, info_str);
+
+        info_str = talloc_asprintf(ctx, "%u", info2->priority);
+        if (info_str == NULL) {
+                return WERR_NOMEM;
+        }
+        ads_mod_str(ctx, mods, SPOOL_REG_PRIORITY, info_str);
+
+        if (info2->attributes & PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS) {
+                ads_mod_str(ctx, mods, SPOOL_REG_PRINTKEEPPRINTEDJOBS, "TRUE");
+        } else {
+                ads_mod_str(ctx, mods, SPOOL_REG_PRINTKEEPPRINTEDJOBS, "FALSE");
+        }
+
+        switch (info2->attributes & 0x3) {
+        case 0:
+                ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING,
+                            SPOOL_REGVAL_PRINTWHILESPOOLING);
+                break;
+        case 1:
+                ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING,
+                            SPOOL_REGVAL_PRINTAFTERSPOOLED);
+                break;
+        case 2:
+                ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING,
+                            SPOOL_REGVAL_PRINTDIRECT);
+                break;
+        default:
+                DEBUG(3, ("unsupported printer attributes %x\n",
+                          info2->attributes));
+        }
+
+        return WERR_OK;
+}
+
 static WERROR nt_printer_publish_ads(struct messaging_context *msg_ctx,
                                      ADS_STRUCT *ads,
@@ -113 +267 @@
 
         /* figure out where to publish */
-        ads_find_machine_acct(ads, &res, global_myname());
+        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()));
+                TALLOC_FREE(ctx);
+                return WERR_NOT_FOUND;
+        }
 
         /* We use ldap_get_dn here as we need the answer
@@ -119 +279 @@
 
         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;
         }
-        ads_msgfree(ads, res);
         srv_cn_utf8 = ldap_explode_dn(srv_dn_utf8, 1);
         if (!srv_cn_utf8) {
@@ -168 +328 @@
 
         if (mods == NULL) {
-                SAFE_FREE(prt_dn);
-                TALLOC_FREE(ctx);
-                return WERR_NOMEM;
-        }
-
-        ads_mod_str(ctx, &mods, SPOOL_REG_PRINTERNAME, printer);
+                TALLOC_FREE(ctx);
+                return WERR_NOMEM;
+        }
+
+        win_rc = nt_printer_info_to_mods(ctx, pinfo2, &mods);
+        if (!W_ERROR_IS_OK(win_rc)) {
+                TALLOC_FREE(ctx);
+                return win_rc;
+        }
 
         /* publish it */
@@ -267 +430 @@
                 break;
         case DSPRINT_UNPUBLISH:
-                pinfo2->attributes ^= PRINTER_ATTRIBUTE_PUBLISHED;
+                pinfo2->attributes &= (~PRINTER_ATTRIBUTE_PUBLISHED);
                 break;
         default:
@@ -391 +554 @@
                           const struct auth_serversupplied_info *session_info,
                           struct messaging_context *msg_ctx,
-                          const char *servername, char *printer, struct GUID *guid,
+                          const char *servername,
+                          const char *printer,
                           struct spoolss_PrinterInfo2 **info2)
 {
         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
-        enum winreg_Type type;
-        uint8_t *data;
-        uint32_t data_size;
         WERROR result;
-        NTSTATUS status;
         struct dcerpc_binding_handle *b;
 
@@ -421 +581 @@
         }
 
-        if (!guid) {
-                goto done;
-        }
-
-        /* fetching printer guids really ought to be a separate function. */
-
-        result = winreg_get_printer_dataex(mem_ctx, b,
-                                           printer,
-                                           SPOOL_DSSPOOLER_KEY, "objectGUID",
-                                           &type, &data, &data_size);
-        if (!W_ERROR_IS_OK(result)) {
-                TALLOC_FREE(pinfo2);
-                return false;
-        }
-
-        /* We used to store the guid as REG_BINARY, then swapped
-           to REG_SZ for Vista compatibility so check for both */
-
-        switch (type) {
-        case REG_SZ:
-                status = GUID_from_string((char *)data, guid);
-                if (!NT_STATUS_IS_OK(status)) {
-                        TALLOC_FREE(pinfo2);
-                        return false;
-                }
-                break;
-
-        case REG_BINARY:
-                if (data_size != sizeof(struct GUID)) {
-                        TALLOC_FREE(pinfo2);
-                        return false;
-                }
-                memcpy(guid, data, sizeof(struct GUID));
-                break;
-        default:
-                DEBUG(0,("is_printer_published: GUID value stored as "
-                         "invaluid type (%d)\n", type));
-                break;
-        }
-
-done:
         if (info2) {
                 *info2 = talloc_move(mem_ctx, &pinfo2);
@@ -469 +588 @@
 }
 #else
+WERROR nt_printer_guid_get(TALLOC_CTX *mem_ctx,
+                           const struct auth_serversupplied_info *session_info,
+                           struct messaging_context *msg_ctx,
+                           const char *printer, struct GUID *guid)
+{
+        return WERR_NOT_SUPPORTED;
+}
+
 WERROR nt_printer_publish(TALLOC_CTX *mem_ctx,
                           const struct auth_serversupplied_info *session_info,
@@ -486 +613 @@
                           const struct auth_serversupplied_info *session_info,
                           struct messaging_context *msg_ctx,
-                          const char *servername, char *printer, struct GUID *guid,
+                          const char *servername,
+                          const char *printer,
                           struct spoolss_PrinterInfo2 **info2)
 {

trunk/server/source3/printing/nt_printing_migrate.c

@@ -104 +104 @@
                                      const char *key_name,
                                      unsigned char *data,
-                                     size_t length)
+                                     size_t length,
+                                     bool do_string_conversion)
 {
         struct dcerpc_binding_handle *b = winreg_pipe->binding_handle;
@@ -122 +123 @@
         ZERO_STRUCT(r);
 
+        if (do_string_conversion) {
+                r.string_flags = LIBNDR_FLAG_STR_ASCII;
+        }
+
         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
                    (ndr_pull_flags_fn_t)ndr_pull_ntprinting_driver);
@@ -178 +183 @@
                                       const char *key_name,
                                       unsigned char *data,
-                                      size_t length)
+                                      size_t length,
+                                      bool do_string_conversion)
 {
         struct dcerpc_binding_handle *b = winreg_pipe->binding_handle;
@@ -200 +206 @@
 
         ZERO_STRUCT(r);
+
+        if (do_string_conversion) {
+                r.info.string_flags = LIBNDR_FLAG_STR_ASCII;
+        }
 
         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,

trunk/server/source3/printing/nt_printing_migrate.h

@@ -31 +31 @@
                                      const char *key_name,
                                      unsigned char *data,
-                                     size_t length);
+                                     size_t length,
+                                     bool do_string_conversion);
 NTSTATUS printing_tdb_migrate_printer(TALLOC_CTX *mem_ctx,
                                       struct rpc_pipe_client *winreg_pipe,
                                       const char *key_name,
                                       unsigned char *data,
-                                      size_t length);
+                                      size_t length,
+                                      bool do_string_conversion);
 NTSTATUS printing_tdb_migrate_secdesc(TALLOC_CTX *mem_ctx,
                                       struct rpc_pipe_client *winreg_pipe,

trunk/server/source3/printing/nt_printing_migrate_internal.c

@@ -115 +115 @@
                                                 (const char *) kbuf.dptr + strlen(DRIVERS_PREFIX),
                                                 dbuf.dptr,
-                                                dbuf.dsize);
+                                                dbuf.dsize,
+                                                false);
                         SAFE_FREE(dbuf.dptr);
                         if (!NT_STATUS_IS_OK(status)) {
@@ -131 +132 @@
                                                  printer_name,
                                                  dbuf.dptr,
-                                                 dbuf.dsize);
+                                                 dbuf.dsize,
+                                                 false);
                         SAFE_FREE(dbuf.dptr);
                         if (!NT_STATUS_IS_OK(status)) {

trunk/server/source3/printing/printing.c

@@ -1661 +1661 @@
 }
 
+/****************************************************************************
+ 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)
@@ -1683 +1701 @@
 }
 
+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;
 
@@ -1718 +1773 @@
                 int ret;
                 NTSTATUS status;
+                struct tevent_signal *se;
 
                 /* Child. */
@@ -1732 +1788 @@
                 }
 
-                smbd_setup_sig_term_handler();
-                smbd_setup_sig_hup_handler(ev, msg_ctx);
+                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(),
@@ -1747 +1813 @@
                 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,
@@ -1755 +1823 @@
                         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,

trunk/server/source3/printing/spoolssd.c

@@ -72 +72 @@
         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);
-        spoolss_reopen_logs();
 }
 
@@ -112 +125 @@
         change_to_root_user();
         DEBUG(1,("Reloading printers after SIGHUP\n"));
-        reload_printers(ev, msg_ctx);
         spoolss_reopen_logs();
 }
@@ -199 +211 @@
         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);
 
         /*