2 Samba Unix/Linux SMB client library
3 Distributed SMB/CIFS Server Management Utility
4 Copyright (C) 2004 Guenther Deschner (gd@samba.org)
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #include "utils/net.h"
24 const char *long_archi;
25 const char *short_archi;
30 /* support itanium as well */
31 static const struct table_node archi_table[]= {
33 {"Windows 4.0", "WIN40", 0 },
34 {"Windows NT x86", "W32X86", 2 },
35 {"Windows NT x86", "W32X86", 3 },
36 {"Windows NT R4000", "W32MIPS", 2 },
37 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
38 {"Windows NT PowerPC", "W32PPC", 2 },
39 {"Windows IA64", "IA64", 3 },
40 {"Windows x64", "x64", 3 },
46 * The display-functions for Security-Descriptors were taken from rpcclient
48 * They reside here for debugging purpose and should
49 * possibly be removed later on
52 /****************************************************************************
53 convert a security permissions into a string
54 ****************************************************************************/
55 char *get_sec_mask_str(uint32 type)
57 static fstring typestr="";
61 if (type & GENERIC_ALL_ACCESS)
62 fstrcat(typestr, "Generic all access ");
63 if (type & GENERIC_EXECUTE_ACCESS)
64 fstrcat(typestr, "Generic execute access ");
65 if (type & GENERIC_WRITE_ACCESS)
66 fstrcat(typestr, "Generic write access ");
67 if (type & GENERIC_READ_ACCESS)
68 fstrcat(typestr, "Generic read access ");
69 if (type & MAXIMUM_ALLOWED_ACCESS)
70 fstrcat(typestr, "MAXIMUM_ALLOWED_ACCESS ");
71 if (type & SYSTEM_SECURITY_ACCESS)
72 fstrcat(typestr, "SYSTEM_SECURITY_ACCESS ");
73 if (type & SYNCHRONIZE_ACCESS)
74 fstrcat(typestr, "SYNCHRONIZE_ACCESS ");
75 if (type & WRITE_OWNER_ACCESS)
76 fstrcat(typestr, "WRITE_OWNER_ACCESS ");
77 if (type & WRITE_DAC_ACCESS)
78 fstrcat(typestr, "WRITE_DAC_ACCESS ");
79 if (type & READ_CONTROL_ACCESS)
80 fstrcat(typestr, "READ_CONTROL_ACCESS ");
81 if (type & DELETE_ACCESS)
82 fstrcat(typestr, "DELETE_ACCESS ");
84 printf("\t\tSpecific bits: 0x%lx\n", (unsigned long)type&SPECIFIC_RIGHTS_MASK);
90 /****************************************************************************
91 display sec_ace structure
92 ****************************************************************************/
93 void display_sec_ace(SEC_ACE *ace)
97 printf("\tACE\n\t\ttype: ");
99 case SEC_ACE_TYPE_ACCESS_ALLOWED:
100 printf("ACCESS ALLOWED");
102 case SEC_ACE_TYPE_ACCESS_DENIED:
103 printf("ACCESS DENIED");
105 case SEC_ACE_TYPE_SYSTEM_AUDIT:
106 printf("SYSTEM AUDIT");
108 case SEC_ACE_TYPE_SYSTEM_ALARM:
109 printf("SYSTEM ALARM");
115 printf(" (%d) flags: %d\n", ace->type, ace->flags);
116 printf("\t\tPermissions: 0x%x: %s\n", ace->info.mask, get_sec_mask_str(ace->info.mask));
118 sid_to_string(sid_str, &ace->trustee);
119 printf("\t\tSID: %s\n\n", sid_str);
123 /****************************************************************************
124 display sec_acl structure
125 ****************************************************************************/
126 void display_sec_acl(SEC_ACL *sec_acl)
130 printf("\tACL\tNum ACEs:\t%d\trevision:\t%x\n",
131 sec_acl->num_aces, sec_acl->revision);
134 if (sec_acl->size != 0 && sec_acl->num_aces != 0)
135 for (i = 0; i < sec_acl->num_aces; i++)
136 display_sec_ace(&sec_acl->ace[i]);
140 /****************************************************************************
141 display sec_desc structure
142 ****************************************************************************/
143 void display_sec_desc(SEC_DESC *sec)
152 display_sec_acl(sec->sacl);
157 display_sec_acl(sec->dacl);
160 if (sec->owner_sid) {
161 sid_to_string(sid_str, sec->owner_sid);
162 printf("\tOwner SID:\t%s\n", sid_str);
166 sid_to_string(sid_str, sec->grp_sid);
167 printf("\tParent SID:\t%s\n", sid_str);
173 * This display-printdriver-functions was borrowed from rpcclient/cmd_spoolss.c.
174 * It is here for debugging purpose and should be removed later on.
177 /****************************************************************************
178 printer info level 3 display function
179 ****************************************************************************/
180 static void display_print_driver_3(DRIVER_INFO_3 *i1)
183 fstring architecture = "";
184 fstring driverpath = "";
185 fstring datafile = "";
186 fstring configfile = "";
187 fstring helpfile = "";
188 fstring dependentfiles = "";
189 fstring monitorname = "";
190 fstring defaultdatatype = "";
198 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
199 rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
200 rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
201 rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
202 rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
203 rpcstr_pull(helpfile, i1->helpfile.buffer, sizeof(helpfile), -1, STR_TERMINATE);
204 rpcstr_pull(monitorname, i1->monitorname.buffer, sizeof(monitorname), -1, STR_TERMINATE);
205 rpcstr_pull(defaultdatatype, i1->defaultdatatype.buffer, sizeof(defaultdatatype), -1, STR_TERMINATE);
207 d_printf ("Printer Driver Info 3:\n");
208 d_printf ("\tVersion: [%x]\n", i1->version);
209 d_printf ("\tDriver Name: [%s]\n",name);
210 d_printf ("\tArchitecture: [%s]\n", architecture);
211 d_printf ("\tDriver Path: [%s]\n", driverpath);
212 d_printf ("\tDatafile: [%s]\n", datafile);
213 d_printf ("\tConfigfile: [%s]\n", configfile);
214 d_printf ("\tHelpfile: [%s]\n\n", helpfile);
217 rpcstr_pull(dependentfiles, i1->dependentfiles+length, sizeof(dependentfiles), -1, STR_TERMINATE);
219 length+=strlen(dependentfiles)+1;
221 if (strlen(dependentfiles) > 0) {
222 d_printf ("\tDependentfiles: [%s]\n", dependentfiles);
230 d_printf ("\tMonitorname: [%s]\n", monitorname);
231 d_printf ("\tDefaultdatatype: [%s]\n\n", defaultdatatype);
237 static void display_reg_value(pstring subkey, REGISTRY_VALUE value)
243 d_printf("\t[%s:%s]: REG_DWORD: 0x%08x\n", subkey, value.valuename,
244 *((uint32 *) value.data_p));
248 rpcstr_pull(text, value.data_p, sizeof(text), value.size,
250 d_printf("\t[%s:%s]: REG_SZ: %s\n", subkey, value.valuename, text);
254 d_printf("\t[%s:%s]: REG_BINARY: unknown length value not displayed\n",
255 subkey, value.valuename);
259 uint16 *curstr = (uint16 *) value.data_p;
260 uint8 *start = value.data_p;
261 d_printf("\t[%s:%s]: REG_MULTI_SZ:\n", subkey, value.valuename);
262 while ((*curstr != 0) &&
263 ((uint8 *) curstr < start + value.size)) {
264 rpcstr_pull(text, curstr, sizeof(text), -1,
266 d_printf("%s\n", text);
267 curstr += strlen(text) + 1;
273 d_printf("\t%s: unknown type %d\n", value.valuename, value.type);
280 * Copies ACLs, DOS-attributes and timestamps from one
281 * file or directory from one connected share to another connected share
283 * @param mem_ctx A talloc-context
284 * @param cli_share_src A connected cli_state
285 * @param cli_share_dst A connected cli_state
286 * @param src_file The source file-name
287 * @param dst_file The destination file-name
288 * @param copy_acls Whether to copy acls
289 * @param copy_attrs Whether to copy DOS attributes
290 * @param copy_timestamps Whether to preserve timestamps
291 * @param is_file Whether this file is a file or a dir
293 * @return Normal NTSTATUS return.
296 net_copy_fileattr(TALLOC_CTX *mem_ctx,
297 struct cli_state *cli_share_src,
298 struct cli_state *cli_share_dst,
299 char *src_name, char *dst_name,
300 BOOL copy_acls, BOOL copy_attrs,
301 BOOL copy_timestamps, BOOL is_file)
303 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
308 time_t f_atime, f_ctime, f_mtime;
311 if (!copy_timestamps && !copy_acls && !copy_attrs)
315 /* open file/dir on the originating server */
317 DEBUGADD(3,("opening %s %s on originating server\n",
318 is_file?"file":"dir", src_name));
320 fnum_src = cli_nt_create(cli_share_src, src_name, READ_CONTROL_ACCESS);
321 if (fnum_src == -1) {
322 DEBUGADD(0,("cannot open %s %s on originating server %s\n",
323 is_file?"file":"dir", src_name, cli_errstr(cli_share_src)));
324 nt_status = cli_nt_error(cli_share_src);
331 /* get the security descriptor */
332 sd = cli_query_secdesc(cli_share_src, fnum_src, mem_ctx);
334 DEBUG(0,("failed to get security descriptor: %s\n",
335 cli_errstr(cli_share_src)));
336 nt_status = cli_nt_error(cli_share_src);
340 if (opt_verbose && DEBUGLEVEL >= 3)
341 display_sec_desc(sd);
345 if (copy_attrs || copy_timestamps) {
347 /* get file attributes */
348 if (!cli_getattrE(cli_share_src, fnum_src, &attr, NULL,
349 &f_ctime, &f_atime, &f_mtime)) {
350 DEBUG(0,("failed to get file-attrs: %s\n",
351 cli_errstr(cli_share_src)));
352 nt_status = cli_nt_error(cli_share_src);
358 /* open the file/dir on the destination server */
360 fnum_dst = cli_nt_create(cli_share_dst, dst_name, WRITE_DAC_ACCESS | WRITE_OWNER_ACCESS);
361 if (fnum_dst == -1) {
362 DEBUG(0,("failed to open %s on the destination server: %s: %s\n",
363 is_file?"file":"dir", dst_name, cli_errstr(cli_share_dst)));
364 nt_status = cli_nt_error(cli_share_dst);
368 if (copy_timestamps) {
371 if (!cli_setattrE(cli_share_dst, fnum_dst, f_ctime, f_atime, f_mtime)) {
372 DEBUG(0,("failed to set file-attrs (timestamps): %s\n",
373 cli_errstr(cli_share_dst)));
374 nt_status = cli_nt_error(cli_share_dst);
382 if (!cli_set_secdesc(cli_share_dst, fnum_dst, sd)) {
383 DEBUG(0,("could not set secdesc on %s: %s\n",
384 dst_name, cli_errstr(cli_share_dst)));
385 nt_status = cli_nt_error(cli_share_dst);
393 if (!cli_setatr(cli_share_dst, dst_name, attr, 0)) {
394 DEBUG(0,("failed to set file-attrs: %s\n",
395 cli_errstr(cli_share_dst)));
396 nt_status = cli_nt_error(cli_share_dst);
404 if (!cli_close(cli_share_src, fnum_src)) {
405 d_printf("could not close %s on originating server: %s\n",
406 is_file?"file":"dir", cli_errstr(cli_share_src));
407 nt_status = cli_nt_error(cli_share_src);
411 if (!cli_close(cli_share_dst, fnum_dst)) {
412 d_printf("could not close %s on destination server: %s\n",
413 is_file?"file":"dir", cli_errstr(cli_share_dst));
414 nt_status = cli_nt_error(cli_share_dst);
419 nt_status = NT_STATUS_OK;
425 cli_close(cli_share_src, fnum_src);
428 cli_close(cli_share_dst, fnum_dst);
435 * Copy a file or directory from a connected share to another connected share
437 * @param mem_ctx A talloc-context
438 * @param cli_share_src A connected cli_state
439 * @param cli_share_dst A connected cli_state
440 * @param src_file The source file-name
441 * @param dst_file The destination file-name
442 * @param copy_acls Whether to copy acls
443 * @param copy_attrs Whether to copy DOS attributes
444 * @param copy_timestamps Whether to preserve timestamps
445 * @param is_file Whether this file is a file or a dir
447 * @return Normal NTSTATUS return.
449 NTSTATUS net_copy_file(TALLOC_CTX *mem_ctx,
450 struct cli_state *cli_share_src,
451 struct cli_state *cli_share_dst,
452 char *src_name, char *dst_name,
453 BOOL copy_acls, BOOL copy_attrs,
454 BOOL copy_timestamps, BOOL is_file)
456 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
459 static int io_bufsize = 64512;
460 int read_size = io_bufsize;
466 if (!src_name || !dst_name)
469 if (cli_share_dst == NULL || cli_share_dst == NULL)
473 /* open on the originating server */
474 DEBUGADD(3,("opening %s %s on originating server\n",
475 is_file ? "file":"dir", src_name));
477 fnum_src = cli_open(cli_share_src, src_name, O_RDONLY, DENY_NONE);
479 fnum_src = cli_nt_create(cli_share_src, src_name, READ_CONTROL_ACCESS);
481 if (fnum_src == -1) {
482 DEBUGADD(0,("cannot open file %s on originating server %s\n",
483 src_name, cli_errstr(cli_share_src)));
484 nt_status = cli_nt_error(cli_share_src);
491 /* open file on the destination server */
492 DEBUGADD(3,("opening file %s on destination server\n", dst_name));
493 fnum_dst = cli_open(cli_share_dst, dst_name,
494 O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
496 if (fnum_dst == -1) {
497 DEBUGADD(1,("cannot create file %s on destination server: %s\n",
498 dst_name, cli_errstr(cli_share_dst)));
499 nt_status = cli_nt_error(cli_share_dst);
503 /* allocate memory */
504 if (!(data = (char *)malloc(read_size))) {
505 d_printf("malloc fail for size %d\n", read_size);
506 nt_status = NT_STATUS_NO_MEMORY;
515 d_printf("copying [\\\\%s\\%s%s] => [\\\\%s\\%s%s] "
516 "%s ACLs and %s DOS Attributes %s\n",
517 cli_share_src->desthost, cli_share_src->share, src_name,
518 cli_share_dst->desthost, cli_share_dst->share, dst_name,
519 copy_acls ? "with" : "without",
520 copy_attrs ? "with" : "without",
521 copy_timestamps ? "(preserving timestamps)" : "" );
529 n = cli_read(cli_share_src, fnum_src, data, nread + start,
535 ret = cli_write(cli_share_dst, fnum_dst, 0, data,
539 d_printf("Error writing file: %s\n",
540 cli_errstr(cli_share_dst));
541 nt_status = cli_nt_error(cli_share_dst);
549 if (!is_file && !cli_chkpath(cli_share_dst, dst_name)) {
552 DEBUGADD(3,("creating dir %s on the destination server\n",
555 if (!cli_mkdir(cli_share_dst, dst_name)) {
556 DEBUG(0,("cannot create directory %s: %s\n",
557 dst_name, cli_errstr(cli_share_dst)));
558 nt_status = NT_STATUS_NO_SUCH_FILE;
561 if (!cli_chkpath(cli_share_dst, dst_name)) {
562 d_printf("cannot check for directory %s: %s\n",
563 dst_name, cli_errstr(cli_share_dst));
570 if (!cli_close(cli_share_src, fnum_src)) {
571 d_printf("could not close file on originating server: %s\n",
572 cli_errstr(cli_share_src));
573 nt_status = cli_nt_error(cli_share_src);
577 if (is_file && !cli_close(cli_share_dst, fnum_dst)) {
578 d_printf("could not close file on destination server: %s\n",
579 cli_errstr(cli_share_dst));
580 nt_status = cli_nt_error(cli_share_dst);
584 /* possibly we have to copy some file-attributes / acls / sd */
585 nt_status = net_copy_fileattr(mem_ctx, cli_share_src, cli_share_dst,
586 src_name, dst_name, copy_acls,
587 copy_attrs, copy_timestamps, is_file);
588 if (!NT_STATUS_IS_OK(nt_status))
592 nt_status = NT_STATUS_OK;
598 cli_close(cli_share_src, fnum_src);
601 cli_close(cli_share_dst, fnum_dst);
610 * Copy a driverfile from on connected share to another connected share
611 * This silently assumes that a driver-file is picked up from
613 * \\src_server\print$\{arch}\{version}\file
617 * \\dst_server\print$\{arch}\file
619 * to be added via setdriver-calls later.
620 * @param mem_ctx A talloc-context
621 * @param cli_share_src A cli_state connected to source print$-share
622 * @param cli_share_dst A cli_state connected to destination print$-share
623 * @param file The file-name to be copied
624 * @param short_archi The name of the driver-architecture (short form)
626 * @return Normal NTSTATUS return.
628 static NTSTATUS net_copy_driverfile(TALLOC_CTX *mem_ctx,
629 struct cli_state *cli_share_src,
630 struct cli_state *cli_share_dst,
631 char *file, const char *short_archi) {
633 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
641 /* scroll through the file until we have the part
642 beyond archi_table.short_archi */
644 while (next_token(&p, tok, "\\", sizeof(tok))) {
645 if (strequal(tok, short_archi)) {
646 next_token(&p, version, "\\", sizeof(version));
647 next_token(&p, filename, "\\", sizeof(filename));
651 /* build source file name */
652 if (asprintf(&src_name, "\\%s\\%s\\%s", short_archi, version, filename) < 0 )
653 return NT_STATUS_NO_MEMORY;
656 /* create destination file name */
657 if (asprintf(&dst_name, "\\%s\\%s", short_archi, filename) < 0 )
658 return NT_STATUS_NO_MEMORY;
661 /* finally copy the file */
662 nt_status = net_copy_file(mem_ctx, cli_share_src, cli_share_dst,
663 src_name, dst_name, False, False, False, True);
664 if (!NT_STATUS_IS_OK(nt_status))
667 nt_status = NT_STATUS_OK;
678 * Check for existing Architecture directory on a given server
680 * @param cli_share A cli_state connected to a print$-share
681 * @param short_archi The Architecture for the print-driver
683 * @return Normal NTSTATUS return.
686 check_arch_dir(struct cli_state *cli_share, const char *short_archi)
689 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
692 if (asprintf(&dir, "\\%s", short_archi) < 0) {
693 return NT_STATUS_NO_MEMORY;
696 DEBUG(10,("creating print-driver dir for architecture: %s\n",
699 if (!cli_mkdir(cli_share, dir)) {
700 DEBUG(1,("cannot create directory %s: %s\n",
701 dir, cli_errstr(cli_share)));
702 nt_status = NT_STATUS_NO_SUCH_FILE;
705 if (!cli_chkpath(cli_share, dir)) {
706 d_printf("cannot check %s: %s\n",
707 dir, cli_errstr(cli_share));
711 nt_status = NT_STATUS_OK;
720 * Copy a print-driver (level 3) from one connected print$-share to another
721 * connected print$-share
723 * @param mem_ctx A talloc-context
724 * @param cli_share_src A cli_state connected to a print$-share
725 * @param cli_share_dst A cli_state connected to a print$-share
726 * @param short_archi The Architecture for the print-driver
727 * @param i1 The DRIVER_INFO_3-struct
729 * @return Normal NTSTATUS return.
732 copy_print_driver_3(TALLOC_CTX *mem_ctx,
733 struct cli_state *cli_share_src,
734 struct cli_state *cli_share_dst,
735 const char *short_archi, DRIVER_INFO_3 *i1)
737 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
742 fstring driverpath = "";
743 fstring datafile = "";
744 fstring configfile = "";
745 fstring helpfile = "";
746 fstring dependentfiles = "";
751 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
752 rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
753 rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
754 rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
755 rpcstr_pull(helpfile, i1->helpfile.buffer, sizeof(helpfile), -1, STR_TERMINATE);
759 d_printf("copying driver: [%s], for architecture: [%s], version: [%d]\n",
760 name, short_archi, i1->version);
762 nt_status = net_copy_driverfile(mem_ctx, cli_share_src, cli_share_dst,
763 driverpath, short_archi);
764 if (!NT_STATUS_IS_OK(nt_status))
767 nt_status = net_copy_driverfile(mem_ctx, cli_share_src, cli_share_dst,
768 datafile, short_archi);
769 if (!NT_STATUS_IS_OK(nt_status))
772 nt_status = net_copy_driverfile(mem_ctx, cli_share_src, cli_share_dst,
773 configfile, short_archi);
774 if (!NT_STATUS_IS_OK(nt_status))
777 nt_status = net_copy_driverfile(mem_ctx, cli_share_src, cli_share_dst,
778 helpfile, short_archi);
779 if (!NT_STATUS_IS_OK(nt_status))
783 rpcstr_pull(dependentfiles, i1->dependentfiles+length, sizeof(dependentfiles), -1, STR_TERMINATE);
784 length+=strlen(dependentfiles)+1;
785 if (strlen(dependentfiles) > 0) {
787 nt_status = net_copy_driverfile(mem_ctx,
788 cli_share_src, cli_share_dst,
789 dependentfiles, short_archi);
790 if (!NT_STATUS_IS_OK(nt_status))
802 * net_spoolss-functions
803 * =====================
805 * the net_spoolss-functions aim to simplify spoolss-client-functions
806 * required during the migration-process wrt buffer-sizes, returned
809 * this greatly reduces the complexitiy of the migrate-functions.
814 net_spoolss_enum_printers(struct cli_state *cli, TALLOC_CTX *mem_ctx,
815 char *name, uint32 flags, uint32 level,
816 uint32 *num_printers, PRINTER_INFO_CTR *ctr)
823 result = cli_spoolss_enum_printers(
824 cli, mem_ctx, 0, &needed, name, flags,
825 level, num_printers, ctr);
827 if (W_ERROR_V(result) == W_ERROR_V(WERR_INSUFFICIENT_BUFFER))
828 result = cli_spoolss_enum_printers(
829 cli, mem_ctx, needed, NULL, name, flags,
830 level, num_printers, ctr);
833 if (!W_ERROR_IS_OK(result)) {
834 printf("cannot enum printers: %s\n", dos_errstr(result));
843 net_spoolss_open_printer_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
844 const char *printername, uint32 access_required,
845 const char *username, POLICY_HND *hnd)
848 fstring servername, printername2;
850 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
852 fstrcpy(printername2, servername);
853 fstrcat(printername2, "\\");
854 fstrcat(printername2, printername);
856 DEBUG(10,("connecting to: %s as %s for %s and access: %x\n",
857 servername, username, printername2, access_required));
860 result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername2,
862 servername, username, hnd);
864 /* be more verbose */
865 if (W_ERROR_V(result) == W_ERROR_V(WERR_ACCESS_DENIED)) {
866 d_printf("no access to printer [%s] on [%s] for user [%s] granted\n",
867 printername2, servername, username);
871 if (!W_ERROR_IS_OK(result)) {
872 d_printf("cannot open printer %s on server %s: %s\n",
873 printername2, servername, dos_errstr(result));
877 DEBUG(2,("got printer handle for printer: %s, server: %s\n",
878 printername2, servername));
885 net_spoolss_getprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
886 POLICY_HND *hnd, uint32 level,
887 PRINTER_INFO_CTR *ctr)
892 /* getprinter call */
893 result = cli_spoolss_getprinter(cli,
894 mem_ctx, 0, &needed, hnd, level, ctr);
896 if (W_ERROR_V(result) == W_ERROR_V(WERR_INSUFFICIENT_BUFFER))
897 result = cli_spoolss_getprinter(cli,
898 mem_ctx, needed, NULL, hnd, level, ctr);
900 if (!W_ERROR_IS_OK(result)) {
901 printf("cannot get printer-info: %s\n", dos_errstr(result));
910 net_spoolss_setprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
911 POLICY_HND *hnd, uint32 level,
912 PRINTER_INFO_CTR *ctr)
916 /* setprinter call */
917 result = cli_spoolss_setprinter(cli, mem_ctx, hnd, level, ctr, 0);
919 if (!W_ERROR_IS_OK(result)) {
920 printf("cannot set printer-info: %s\n", dos_errstr(result));
929 net_spoolss_setprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
930 POLICY_HND *hnd, REGISTRY_VALUE *value)
934 /* setprinterdata call */
935 result = cli_spoolss_setprinterdata(cli, mem_ctx, hnd, value);
937 if (!W_ERROR_IS_OK(result)) {
938 printf ("unable to set printerdata: %s\n", dos_errstr(result));
947 net_spoolss_enumprinterkey(struct cli_state *cli, TALLOC_CTX *mem_ctx,
948 POLICY_HND *hnd, const char *keyname,
954 /* enumprinterkey call */
955 result = cli_spoolss_enumprinterkey(
956 cli, mem_ctx, 0, &needed, hnd, keyname, NULL, NULL);
958 if (W_ERROR_V(result) == W_ERROR_V(WERR_MORE_DATA))
959 result = cli_spoolss_enumprinterkey(
960 cli, mem_ctx, needed, NULL, hnd, keyname, keylist,
963 if (!W_ERROR_IS_OK(result)) {
964 printf("enumprinterkey failed: %s\n", dos_errstr(result));
973 net_spoolss_enumprinterdataex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
975 POLICY_HND *hnd, const char *keyname,
981 /* enumprinterdataex call */
982 result = cli_spoolss_enumprinterdataex(
983 cli, mem_ctx, 0, &needed, hnd, keyname, NULL);
985 if (W_ERROR_V(result) == W_ERROR_V(WERR_MORE_DATA))
986 result = cli_spoolss_enumprinterdataex(
987 cli, mem_ctx, needed, NULL, hnd, keyname, ctr);
989 if (!W_ERROR_IS_OK(result)) {
990 printf("enumprinterdataex failed: %s\n", dos_errstr(result));
999 net_spoolss_setprinterdataex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1000 POLICY_HND *hnd, char *keyname,
1001 REGISTRY_VALUE *value)
1005 /* setprinterdataex call */
1006 result = cli_spoolss_setprinterdataex(cli, mem_ctx, hnd,
1009 if (!W_ERROR_IS_OK(result)) {
1010 printf("could not set printerdataex: %s\n", dos_errstr(result));
1019 net_spoolss_enumforms(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1020 POLICY_HND *hnd, int level, uint32 *num_forms,
1027 /* enumforms call */
1028 result = cli_spoolss_enumforms(
1029 cli, mem_ctx, 0, &needed, hnd, level, num_forms, forms);
1031 if (W_ERROR_V(result) == W_ERROR_V(WERR_INSUFFICIENT_BUFFER))
1032 result = cli_spoolss_enumforms(
1033 cli, mem_ctx, needed, NULL, hnd, level,
1036 if (!W_ERROR_IS_OK(result)) {
1037 printf("could not enum forms: %s\n", dos_errstr(result));
1046 net_spoolss_enumprinterdrivers (struct cli_state *cli, TALLOC_CTX *mem_ctx,
1047 uint32 level, const char *env,
1048 uint32 *num_drivers,
1049 PRINTER_DRIVER_CTR *ctr)
1054 /* enumprinterdrivers call */
1055 result = cli_spoolss_enumprinterdrivers(
1056 cli, mem_ctx, 0, &needed, level,
1057 env, num_drivers, ctr);
1059 if (W_ERROR_V(result) == W_ERROR_V(WERR_INSUFFICIENT_BUFFER))
1060 result = cli_spoolss_enumprinterdrivers(
1061 cli, mem_ctx, needed, NULL, level,
1062 env, num_drivers, ctr);
1064 if (!W_ERROR_IS_OK(result)) {
1065 printf("cannot enum drivers: %s\n", dos_errstr(result));
1074 net_spoolss_getprinterdriver(struct cli_state *cli,
1075 TALLOC_CTX *mem_ctx,
1076 POLICY_HND *hnd, uint32 level,
1077 const char *env, int version,
1078 PRINTER_DRIVER_CTR *ctr)
1083 /* getprinterdriver call */
1084 result = cli_spoolss_getprinterdriver(
1085 cli, mem_ctx, 0, &needed, hnd, level,
1088 if (W_ERROR_V(result) == W_ERROR_V(WERR_INSUFFICIENT_BUFFER))
1089 result = cli_spoolss_getprinterdriver(
1090 cli, mem_ctx, needed, NULL, hnd, level,
1093 if (!W_ERROR_IS_OK(result)) {
1094 DEBUG(1,("cannot get driver (for architecture: %s): %s\n",
1095 env, dos_errstr(result)));
1096 if (W_ERROR_V(result) != W_ERROR_V(WERR_UNKNOWN_PRINTER_DRIVER) &&
1097 W_ERROR_V(result) != W_ERROR_V(WERR_INVALID_ENVIRONMENT)) {
1098 printf("cannot get driver: %s\n", dos_errstr(result));
1108 net_spoolss_addprinterdriver(struct cli_state *cli,
1109 TALLOC_CTX *mem_ctx, uint32 level,
1110 PRINTER_DRIVER_CTR *ctr)
1114 /* addprinterdriver call */
1115 result = cli_spoolss_addprinterdriver(cli, mem_ctx, level, ctr);
1117 /* be more verbose */
1118 if (W_ERROR_V(result) == W_ERROR_V(WERR_ACCESS_DENIED)) {
1119 printf("You are not allowed to add drivers\n");
1122 if (!W_ERROR_IS_OK(result)) {
1123 printf("cannot add driver: %s\n", dos_errstr(result));
1131 * abstraction function to get uint32 num_printers and PRINTER_INFO_CTR ctr
1132 * for a single printer or for all printers depending on argc/argv
1135 get_printer_info(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1136 int level, int argc, const char **argv,
1137 uint32 *num_printers, PRINTER_INFO_CTR *ctr)
1143 /* no arguments given, enumerate all printers */
1146 if (!net_spoolss_enum_printers(cli, mem_ctx, NULL,
1147 PRINTER_ENUM_LOCAL|PRINTER_ENUM_SHARED,
1148 level, num_printers, ctr))
1155 /* argument given, get a single printer by name */
1156 sharename = strdup(argv[0]);
1158 if (!net_spoolss_open_printer_ex(cli, mem_ctx, sharename,
1159 MAXIMUM_ALLOWED_ACCESS, cli->user_name, &hnd))
1162 if (!net_spoolss_getprinter(cli, mem_ctx, &hnd, level, ctr)) {
1163 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
1167 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
1172 DEBUG(3,("got %d printers\n", *num_printers));
1180 * List print-queues (including local printers that are not shared)
1182 * All parameters are provided by the run_rpc_command function, except for
1183 * argc, argv which are passed through.
1185 * @param domain_sid The domain sid aquired from the remote server
1186 * @param cli A cli_state connected to the server.
1187 * @param mem_ctx Talloc context, destoyed on compleation of the function.
1188 * @param argc Standard main() style argc
1189 * @param argv Standard main() style argv. Initial components are already
1192 * @return Normal NTSTATUS return.
1194 NTSTATUS rpc_printer_list_internals(const DOM_SID *domain_sid, const char *domain_name,
1195 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1196 int argc, const char **argv)
1198 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1199 uint32 i, num_printers;
1201 pstring printername, sharename;
1202 PRINTER_INFO_CTR ctr;
1204 printf("listing printers\n");
1206 if (!get_printer_info(cli, mem_ctx, level, argc, argv, &num_printers, &ctr))
1209 for (i = 0; i < num_printers; i++) {
1211 /* do some initialization */
1212 rpcstr_pull(printername, ctr.printers_2[i].printername.buffer,
1213 sizeof(printername), -1, STR_TERMINATE);
1214 rpcstr_pull(sharename, ctr.printers_2[i].sharename.buffer,
1215 sizeof(sharename), -1, STR_TERMINATE);
1217 d_printf("printer %d: %s, shared as: %s\n",
1218 i+1, printername, sharename);
1221 return NT_STATUS_OK;
1226 * List printer-drivers from a server
1228 * All parameters are provided by the run_rpc_command function, except for
1229 * argc, argv which are passed through.
1231 * @param domain_sid The domain sid aquired from the remote server
1232 * @param cli A cli_state connected to the server.
1233 * @param mem_ctx Talloc context, destoyed on compleation of the function.
1234 * @param argc Standard main() style argc
1235 * @param argv Standard main() style argv. Initial components are already
1238 * @return Normal NTSTATUS return.
1240 NTSTATUS rpc_printer_driver_list_internals(const DOM_SID *domain_sid, const char *domain_name,
1241 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1242 int argc, const char **argv)
1244 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1247 PRINTER_DRIVER_CTR drv_ctr_enum;
1250 ZERO_STRUCT(drv_ctr_enum);
1253 printf("listing printer-drivers\n");
1255 for (i=0; archi_table[i].long_archi!=NULL; i++) {
1259 /* enum remote drivers */
1260 if (!net_spoolss_enumprinterdrivers(cli, mem_ctx, level,
1261 archi_table[i].long_archi,
1262 &num_drivers, &drv_ctr_enum)) {
1264 nt_status = NT_STATUS_UNSUCCESSFUL;
1268 if (num_drivers == 0) {
1269 d_printf ("no drivers found on server for architecture: [%s].\n",
1270 archi_table[i].long_archi);
1274 d_printf("got %d printer-drivers for architecture: [%s]\n",
1275 num_drivers, archi_table[i].long_archi);
1278 /* do something for all drivers for architecture */
1279 for (d = 0; d < num_drivers; d++) {
1280 display_print_driver_3(&(drv_ctr_enum.info3[d]));
1284 nt_status = NT_STATUS_OK;
1292 * Publish print-queues with args-wrapper
1294 * @param cli A cli_state connected to the server.
1295 * @param mem_ctx Talloc context, destoyed on compleation of the function.
1296 * @param argc Standard main() style argc
1297 * @param argv Standard main() style argv. Initial components are already
1301 * @return Normal NTSTATUS return.
1304 static NTSTATUS rpc_printer_publish_internals_args(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1305 int argc, const char **argv, uint32 action)
1307 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1308 uint32 i, num_printers;
1310 pstring printername, sharename;
1311 PRINTER_INFO_CTR ctr, ctr_pub;
1313 BOOL got_hnd = False;
1315 const char *action_str;
1317 if (!get_printer_info(cli, mem_ctx, 2, argc, argv, &num_printers, &ctr))
1320 for (i = 0; i < num_printers; i++) {
1322 /* do some initialization */
1323 rpcstr_pull(printername, ctr.printers_2[i].printername.buffer,
1324 sizeof(printername), -1, STR_TERMINATE);
1325 rpcstr_pull(sharename, ctr.printers_2[i].sharename.buffer,
1326 sizeof(sharename), -1, STR_TERMINATE);
1328 /* open printer handle */
1329 if (!net_spoolss_open_printer_ex(cli, mem_ctx, sharename,
1330 PRINTER_ALL_ACCESS, cli->user_name, &hnd))
1335 /* check for existing dst printer */
1336 if (!net_spoolss_getprinter(cli, mem_ctx, &hnd, level, &ctr_pub))
1339 /* check action and set string */
1341 case SPOOL_DS_PUBLISH:
1342 action_str = "published";
1344 case SPOOL_DS_UPDATE:
1345 action_str = "updated";
1347 case SPOOL_DS_UNPUBLISH:
1348 action_str = "unpublished";
1351 action_str = "unknown action";
1352 printf("unkown action: %d\n", action);
1356 ctr_pub.printers_7->action = action;
1358 result = cli_spoolss_setprinter(cli, mem_ctx, &hnd, level, &ctr_pub, 0);
1359 if (!W_ERROR_IS_OK(result) && (W_ERROR_V(result) =! W_ERROR_V(WERR_IO_PENDING))) {
1360 printf("cannot set printer-info: %s\n", dos_errstr(result));
1364 printf("successfully %s printer %s in Active Directory\n", action_str, sharename);
1367 nt_status = NT_STATUS_OK;
1371 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
1376 NTSTATUS rpc_printer_publish_publish_internals(const DOM_SID *domain_sid, const char *domain_name,
1377 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1378 int argc, const char **argv)
1380 return rpc_printer_publish_internals_args(cli, mem_ctx, argc, argv, SPOOL_DS_PUBLISH);
1383 NTSTATUS rpc_printer_publish_unpublish_internals(const DOM_SID *domain_sid, const char *domain_name,
1384 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1385 int argc, const char **argv)
1387 return rpc_printer_publish_internals_args(cli, mem_ctx, argc, argv, SPOOL_DS_UNPUBLISH);
1390 NTSTATUS rpc_printer_publish_update_internals(const DOM_SID *domain_sid, const char *domain_name,
1391 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1392 int argc, const char **argv)
1394 return rpc_printer_publish_internals_args(cli, mem_ctx, argc, argv, SPOOL_DS_UPDATE);
1398 * List print-queues w.r.t. thei publishing
1400 * All parameters are provided by the run_rpc_command function, except for
1401 * argc, argv which are passed through.
1403 * @param domain_sid The domain sid aquired from the remote server
1404 * @param cli A cli_state connected to the server.
1405 * @param mem_ctx Talloc context, destoyed on compleation of the function.
1406 * @param argc Standard main() style argc
1407 * @param argv Standard main() style argv. Initial components are already
1410 * @return Normal NTSTATUS return.
1412 NTSTATUS rpc_printer_publish_list_internals(const DOM_SID *domain_sid, const char *domain_name,
1413 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1414 int argc, const char **argv)
1416 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1417 uint32 i, num_printers;
1419 pstring printername, sharename;
1421 PRINTER_INFO_CTR ctr, ctr_pub;
1423 BOOL got_hnd = False;
1426 if (!get_printer_info(cli, mem_ctx, 2, argc, argv, &num_printers, &ctr))
1429 for (i = 0; i < num_printers; i++) {
1431 ZERO_STRUCT(ctr_pub);
1433 /* do some initialization */
1434 rpcstr_pull(printername, ctr.printers_2[i].printername.buffer,
1435 sizeof(printername), -1, STR_TERMINATE);
1436 rpcstr_pull(sharename, ctr.printers_2[i].sharename.buffer,
1437 sizeof(sharename), -1, STR_TERMINATE);
1439 /* open printer handle */
1440 if (!net_spoolss_open_printer_ex(cli, mem_ctx, sharename,
1441 PRINTER_ALL_ACCESS, cli->user_name, &hnd))
1446 /* check for existing dst printer */
1447 if (!net_spoolss_getprinter(cli, mem_ctx, &hnd, level, &ctr_pub))
1450 rpcstr_pull(guid, ctr_pub.printers_7->guid.buffer, sizeof(guid), -1, STR_TERMINATE);
1452 state = ctr_pub.printers_7->action;
1454 case SPOOL_DS_PUBLISH:
1455 printf("printer [%s] is published", sharename);
1457 printf(", guid: %s", guid);
1460 case SPOOL_DS_UNPUBLISH:
1461 printf("printer [%s] is unpublished\n", sharename);
1463 case SPOOL_DS_UPDATE:
1464 printf("printer [%s] is currently updating\n", sharename);
1467 printf("unkown state: %d\n", state);
1472 nt_status = NT_STATUS_OK;
1476 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
1482 * Migrate Printer-ACLs from a source server to the destination server
1484 * All parameters are provided by the run_rpc_command function, except for
1485 * argc, argv which are passed through.
1487 * @param domain_sid The domain sid aquired from the remote server
1488 * @param cli A cli_state connected to the server.
1489 * @param mem_ctx Talloc context, destoyed on compleation of the function.
1490 * @param argc Standard main() style argc
1491 * @param argv Standard main() style argv. Initial components are already
1494 * @return Normal NTSTATUS return.
1496 NTSTATUS rpc_printer_migrate_security_internals(const DOM_SID *domain_sid, const char *domain_name,
1497 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1498 int argc, const char **argv)
1500 /* TODO: what now, info2 or info3 ?
1501 convince jerry that we should add clientside setacls level 3 at least
1503 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1505 uint32 num_printers;
1507 pstring printername = "", sharename = "";
1508 BOOL got_hnd_src = False;
1509 BOOL got_hnd_dst = False;
1510 BOOL got_dst_spoolss_pipe = False;
1511 POLICY_HND hnd_src, hnd_dst;
1512 PRINTER_INFO_CTR ctr_src, ctr_dst, ctr_enum;
1513 struct cli_state *cli_dst = NULL;
1515 ZERO_STRUCT(ctr_src);
1517 DEBUG(3,("copying printer ACLs\n"));
1519 /* connect destination PI_SPOOLSS */
1520 nt_status = connect_pipe(&cli_dst, PI_SPOOLSS, &got_dst_spoolss_pipe);
1521 if (!NT_STATUS_IS_OK(nt_status))
1525 /* enum source printers */
1526 if (!get_printer_info(cli, mem_ctx, level, argc, argv, &num_printers, &ctr_enum)) {
1527 nt_status = NT_STATUS_UNSUCCESSFUL;
1531 if (!num_printers) {
1532 printf ("no printers found on server.\n");
1533 nt_status = NT_STATUS_OK;
1538 /* do something for all printers */
1539 for (i = 0; i < num_printers; i++) {
1541 /* do some initialization */
1542 rpcstr_pull(printername, ctr_enum.printers_2[i].printername.buffer,
1543 sizeof(printername), -1, STR_TERMINATE);
1544 rpcstr_pull(sharename, ctr_enum.printers_2[i].sharename.buffer,
1545 sizeof(sharename), -1, STR_TERMINATE);
1546 /* we can reset NT_STATUS here because we do not
1547 get any real NT_STATUS-codes anymore from now on */
1548 nt_status = NT_STATUS_UNSUCCESSFUL;
1550 d_printf("migrating printer ACLs for: [%s] / [%s]\n",
1551 printername, sharename);
1553 /* according to msdn you have specify these access-rights
1554 to see the security descriptor
1555 - READ_CONTROL (DACL)
1556 - ACCESS_SYSTEM_SECURITY (SACL)
1559 /* open src printer handle */
1560 if (!net_spoolss_open_printer_ex(cli, mem_ctx, sharename,
1561 MAXIMUM_ALLOWED_ACCESS, cli->user_name, &hnd_src))
1567 /* open dst printer handle */
1568 if (!net_spoolss_open_printer_ex(cli_dst, mem_ctx, sharename,
1569 PRINTER_ALL_ACCESS, cli_dst->user_name, &hnd_dst))
1575 /* check for existing dst printer */
1576 if (!net_spoolss_getprinter(cli_dst, mem_ctx, &hnd_dst, level, &ctr_dst))
1579 /* check for existing src printer */
1580 if (!net_spoolss_getprinter(cli, mem_ctx, &hnd_src, 3, &ctr_src))
1584 /* Copy Security Descriptor */
1586 /* copy secdesc (info level 2) */
1587 ctr_dst.printers_2->devmode = NULL;
1588 ctr_dst.printers_2->secdesc = dup_sec_desc(mem_ctx, ctr_src.printers_3->secdesc);
1591 display_sec_desc(ctr_dst.printers_2->secdesc);
1593 if (!net_spoolss_setprinter(cli_dst, mem_ctx, &hnd_dst, 2, &ctr_dst))
1596 DEBUGADD(1,("\tSetPrinter of SECDESC succeeded\n"));
1599 /* close printer handles here */
1601 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
1602 got_hnd_src = False;
1606 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
1607 got_hnd_dst = False;
1612 nt_status = NT_STATUS_OK;
1617 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
1620 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
1622 if (got_dst_spoolss_pipe) {
1623 cli_nt_session_close(cli_dst);
1624 cli_shutdown(cli_dst);
1631 * Migrate printer-forms from a src server to the dst server
1633 * All parameters are provided by the run_rpc_command function, except for
1634 * argc, argv which are passed through.
1636 * @param domain_sid The domain sid aquired from the remote server
1637 * @param cli A cli_state connected to the server.
1638 * @param mem_ctx Talloc context, destoyed on compleation of the function.
1639 * @param argc Standard main() style argc
1640 * @param argv Standard main() style argv. Initial components are already
1643 * @return Normal NTSTATUS return.
1645 NTSTATUS rpc_printer_migrate_forms_internals(const DOM_SID *domain_sid, const char *domain_name,
1646 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1647 int argc, const char **argv)
1649 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1652 uint32 num_printers;
1654 pstring printername = "", sharename = "";
1655 BOOL got_hnd_src = False;
1656 BOOL got_hnd_dst = False;
1657 BOOL got_dst_spoolss_pipe = False;
1658 POLICY_HND hnd_src, hnd_dst;
1659 PRINTER_INFO_CTR ctr_enum, ctr_dst;
1662 struct cli_state *cli_dst = NULL;
1664 ZERO_STRUCT(ctr_enum);
1666 DEBUG(3,("copying forms\n"));
1668 /* connect destination PI_SPOOLSS */
1669 nt_status = connect_pipe(&cli_dst, PI_SPOOLSS, &got_dst_spoolss_pipe);
1670 if (!NT_STATUS_IS_OK(nt_status))
1674 /* enum src printers */
1675 if (!get_printer_info(cli, mem_ctx, 2, argc, argv, &num_printers, &ctr_enum)) {
1676 nt_status = NT_STATUS_UNSUCCESSFUL;
1680 if (!num_printers) {
1681 printf ("no printers found on server.\n");
1682 nt_status = NT_STATUS_OK;
1687 /* do something for all printers */
1688 for (i = 0; i < num_printers; i++) {
1690 /* do some initialization */
1691 rpcstr_pull(printername, ctr_enum.printers_2[i].printername.buffer,
1692 sizeof(printername), -1, STR_TERMINATE);
1693 rpcstr_pull(sharename, ctr_enum.printers_2[i].sharename.buffer,
1694 sizeof(sharename), -1, STR_TERMINATE);
1695 /* we can reset NT_STATUS here because we do not
1696 get any real NT_STATUS-codes anymore from now on */
1697 nt_status = NT_STATUS_UNSUCCESSFUL;
1699 d_printf("migrating printer forms for: [%s] / [%s]\n",
1700 printername, sharename);
1703 /* open src printer handle */
1704 if (!net_spoolss_open_printer_ex(cli, mem_ctx, sharename,
1705 MAXIMUM_ALLOWED_ACCESS, cli->user_name, &hnd_src))
1711 /* open dst printer handle */
1712 if (!net_spoolss_open_printer_ex(cli_dst, mem_ctx, sharename,
1713 PRINTER_ALL_ACCESS, cli->user_name, &hnd_dst))
1719 /* check for existing dst printer */
1720 if (!net_spoolss_getprinter(cli_dst, mem_ctx, &hnd_dst, level, &ctr_dst))
1723 /* finally migrate forms */
1724 if (!net_spoolss_enumforms(cli, mem_ctx, &hnd_src, level, &num_forms, &forms))
1727 DEBUG(1,("got %d forms for printer\n", num_forms));
1730 for (f = 0; f < num_forms; f++) {
1735 /* only migrate FORM_PRINTER types, according to jerry
1736 FORM_BUILTIN-types are hard-coded in samba */
1737 if (forms[f].flag != FORM_PRINTER)
1740 if (forms[f].name.buffer)
1741 rpcstr_pull(form_name, forms[f].name.buffer,
1742 sizeof(form_name), -1, STR_TERMINATE);
1745 d_printf("\tmigrating form # %d [%s] of type [%d]\n",
1746 f, form_name, forms[f].flag);
1748 /* is there a more elegant way to do that ? */
1749 form.flags = FORM_PRINTER;
1750 form.size_x = forms[f].width;
1751 form.size_y = forms[f].length;
1752 form.left = forms[f].left;
1753 form.top = forms[f].top;
1754 form.right = forms[f].right;
1755 form.bottom = forms[f].bottom;
1757 init_unistr2(&form.name, form_name, UNI_STR_TERMINATE);
1759 /* FIXME: there might be something wrong with samba's
1761 result = cli_spoolss_addform(cli_dst, mem_ctx,
1762 &hnd_dst, 1, &form);
1763 if (!W_ERROR_IS_OK(result)) {
1764 d_printf("\tAddForm form %d: [%s] refused.\n",
1769 DEBUGADD(1,("\tAddForm of [%s] succeeded\n", form_name));
1773 /* close printer handles here */
1775 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
1776 got_hnd_src = False;
1780 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
1781 got_hnd_dst = False;
1785 nt_status = NT_STATUS_OK;
1790 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
1793 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
1795 if (got_dst_spoolss_pipe) {
1796 cli_nt_session_close(cli_dst);
1797 cli_shutdown(cli_dst);
1805 * Migrate printer-drivers from a src server to the dst server
1807 * All parameters are provided by the run_rpc_command function, except for
1808 * argc, argv which are passed through.
1810 * @param domain_sid The domain sid aquired from the remote server
1811 * @param cli A cli_state connected to the server.
1812 * @param mem_ctx Talloc context, destoyed on compleation of the function.
1813 * @param argc Standard main() style argc
1814 * @param argv Standard main() style argv. Initial components are already
1817 * @return Normal NTSTATUS return.
1819 NTSTATUS rpc_printer_migrate_drivers_internals(const DOM_SID *domain_sid, const char *domain_name,
1820 struct cli_state *cli, TALLOC_CTX *mem_ctx,
1821 int argc, const char **argv)
1823 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1825 uint32 num_printers;
1827 pstring printername = "", sharename = "";
1828 BOOL got_hnd_src = False;
1829 BOOL got_hnd_dst = False;
1830 BOOL got_dst_spoolss_pipe = False;
1831 BOOL got_src_driver_share = False;
1832 BOOL got_dst_driver_share = False;
1833 POLICY_HND hnd_src, hnd_dst;
1834 PRINTER_DRIVER_CTR drv_ctr_src, drv_ctr_dst;
1835 PRINTER_INFO_CTR info_ctr_enum, info_ctr_dst;
1836 struct cli_state *cli_dst = NULL;
1837 struct cli_state *cli_share_src = NULL;
1838 struct cli_state *cli_share_dst = NULL;
1839 fstring drivername = "";
1841 ZERO_STRUCT(drv_ctr_src);
1842 ZERO_STRUCT(drv_ctr_dst);
1843 ZERO_STRUCT(info_ctr_enum);
1844 ZERO_STRUCT(info_ctr_dst);
1847 DEBUG(3,("copying printer-drivers\n"));
1849 nt_status = connect_pipe(&cli_dst, PI_SPOOLSS, &got_dst_spoolss_pipe);
1850 if (!NT_STATUS_IS_OK(nt_status))
1854 /* open print$-share on the src server */
1855 nt_status = connect_to_service(&cli_share_src, &cli->dest_ip,
1856 cli->desthost, "print$", "A:");
1857 if (!NT_STATUS_IS_OK(nt_status))
1860 got_src_driver_share = True;
1863 /* open print$-share on the dst server */
1864 nt_status = connect_to_service(&cli_share_dst, &cli_dst->dest_ip,
1865 cli_dst->desthost, "print$", "A:");
1866 if (!NT_STATUS_IS_OK(nt_status))
1869 got_dst_driver_share = True;
1872 /* enum src printers */
1873 if (!get_printer_info(cli, mem_ctx, 2, argc, argv, &num_printers, &info_ctr_enum)) {
1874 nt_status = NT_STATUS_UNSUCCESSFUL;
1878 if (!num_printers) {
1879 printf ("no printers found on server.\n");
1880 nt_status = NT_STATUS_OK;
1885 /* do something for all printers */
1886 for (p = 0; p < num_printers; p++) {
1888 /* do some initialization */
1889 rpcstr_pull(printername, info_ctr_enum.printers_2[p].printername.buffer,
1890 sizeof(printername), -1, STR_TERMINATE);
1891 rpcstr_pull(sharename, info_ctr_enum.printers_2[p].sharename.buffer,
1892 sizeof(sharename), -1, STR_TERMINATE);
1893 /* we can reset NT_STATUS here because we do not
1894 get any real NT_STATUS-codes anymore from now on */
1895 nt_status = NT_STATUS_UNSUCCESSFUL;
1897 d_printf("migrating printer driver for: [%s] / [%s]\n",
1898 printername, sharename);
1900 /* open dst printer handle */
1901 if (!net_spoolss_open_printer_ex(cli_dst, mem_ctx, sharename,
1902 PRINTER_ALL_ACCESS, cli->user_name, &hnd_dst))
1907 /* check for existing dst printer */
1908 if (!net_spoolss_getprinter(cli_dst, mem_ctx, &hnd_dst, 2, &info_ctr_dst))
1912 /* open src printer handle */
1913 if (!net_spoolss_open_printer_ex(cli, mem_ctx, sharename,
1914 MAXIMUM_ALLOWED_ACCESS, cli->user_name, &hnd_src))
1920 /* in a first step call getdriver for each shared printer (per arch)
1921 to get a list of all files that have to be copied */
1923 for (i=0; archi_table[i].long_archi!=NULL; i++) {
1926 if (!net_spoolss_getprinterdriver(cli, mem_ctx, &hnd_src,
1927 level, archi_table[i].long_archi,
1928 archi_table[i].version, &drv_ctr_src))
1931 rpcstr_pull(drivername, drv_ctr_src.info3->name.buffer,
1932 sizeof(drivername), -1, STR_TERMINATE);
1935 display_print_driver_3(drv_ctr_src.info3);
1938 /* check arch dir */
1939 nt_status = check_arch_dir(cli_share_dst, archi_table[i].short_archi);
1940 if (!NT_STATUS_IS_OK(nt_status))
1944 /* copy driver-files */
1945 nt_status = copy_print_driver_3(mem_ctx, cli_share_src, cli_share_dst,
1946 archi_table[i].short_archi,
1948 if (!NT_STATUS_IS_OK(nt_status))
1953 if (!net_spoolss_addprinterdriver(cli_dst, mem_ctx, level, &drv_ctr_src)) {
1954 nt_status = NT_STATUS_UNSUCCESSFUL;
1958 DEBUGADD(1,("Sucessfully added driver [%s] for printer [%s]\n",
1959 drivername, printername));
1964 init_unistr(&info_ctr_dst.printers_2->drivername, drivername);
1966 if (!net_spoolss_setprinter(cli_dst, mem_ctx, &hnd_dst, 2, &info_ctr_dst)) {
1967 nt_status = NT_STATUS_UNSUCCESSFUL;
1971 DEBUGADD(1,("Sucessfully set driver %s for printer %s\n",
1972 drivername, printername));
1976 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
1977 got_hnd_dst = False;
1982 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
1983 got_hnd_src = False;
1987 nt_status = NT_STATUS_OK;
1992 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
1995 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
1997 if (got_dst_spoolss_pipe) {
1998 cli_nt_session_close(cli_dst);
1999 cli_shutdown(cli_dst);
2002 if (got_src_driver_share)
2003 cli_shutdown(cli_share_src);
2005 if (got_dst_driver_share)
2006 cli_shutdown(cli_share_dst);
2014 * Migrate printer-queues from a src to the dst server
2015 * (requires a working "addprinter command" to be installed for the local smbd)
2017 * All parameters are provided by the run_rpc_command function, except for
2018 * argc, argv which are passed through.
2020 * @param domain_sid The domain sid aquired from the remote server
2021 * @param cli A cli_state connected to the server.
2022 * @param mem_ctx Talloc context, destoyed on compleation of the function.
2023 * @param argc Standard main() style argc
2024 * @param argv Standard main() style argv. Initial components are already
2027 * @return Normal NTSTATUS return.
2029 NTSTATUS rpc_printer_migrate_printers_internals(const DOM_SID *domain_sid, const char *domain_name,
2030 struct cli_state *cli, TALLOC_CTX *mem_ctx,
2031 int argc, const char **argv)
2034 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
2035 uint32 i = 0, num_printers;
2037 PRINTER_INFO_CTR ctr_src, ctr_dst, ctr_enum;
2038 struct cli_state *cli_dst = NULL;
2039 POLICY_HND hnd_dst, hnd_src;
2040 pstring printername, sharename;
2041 BOOL got_hnd_src = False;
2042 BOOL got_hnd_dst = False;
2043 BOOL got_dst_spoolss_pipe = False;
2045 DEBUG(3,("copying printers\n"));
2047 /* connect destination PI_SPOOLSS */
2048 nt_status = connect_pipe(&cli_dst, PI_SPOOLSS, &got_dst_spoolss_pipe);
2049 if (!NT_STATUS_IS_OK(nt_status))
2054 if (!get_printer_info(cli, mem_ctx, 2, argc, argv, &num_printers, &ctr_enum)) {
2055 nt_status = NT_STATUS_UNSUCCESSFUL;
2059 if (!num_printers) {
2060 printf ("no printers found on server.\n");
2061 nt_status = NT_STATUS_OK;
2066 /* do something for all printers */
2067 for (i = 0; i < num_printers; i++) {
2069 /* do some initialization */
2070 rpcstr_pull(printername, ctr_enum.printers_2[i].printername.buffer,
2071 sizeof(printername), -1, STR_TERMINATE);
2072 rpcstr_pull(sharename, ctr_enum.printers_2[i].sharename.buffer,
2073 sizeof(sharename), -1, STR_TERMINATE);
2074 /* we can reset NT_STATUS here because we do not
2075 get any real NT_STATUS-codes anymore from now on */
2076 nt_status = NT_STATUS_UNSUCCESSFUL;
2078 d_printf("migrating printer queue for: [%s] / [%s]\n",
2079 printername, sharename);
2082 /* open dst printer handle */
2083 if (!net_spoolss_open_printer_ex(cli_dst, mem_ctx, sharename,
2084 PRINTER_ALL_ACCESS, cli->user_name, &hnd_dst)) {
2086 DEBUG(1,("could not open printer: %s\n", sharename));
2092 /* check for existing dst printer */
2093 if (!net_spoolss_getprinter(cli_dst, mem_ctx, &hnd_dst, level, &ctr_dst)) {
2094 printf ("could not get printer, creating printer.\n");
2096 DEBUG(1,("printer already exists: %s\n", sharename));
2097 /* close printer handles here */
2099 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
2100 got_hnd_src = False;
2104 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
2105 got_hnd_dst = False;
2111 /* now get again src printer ctr via getprinter,
2112 we first need a handle for that */
2114 /* open src printer handle */
2115 if (!net_spoolss_open_printer_ex(cli, mem_ctx, sharename,
2116 MAXIMUM_ALLOWED_ACCESS, cli->user_name, &hnd_src))
2121 /* getprinter on the src server */
2122 if (!net_spoolss_getprinter(cli, mem_ctx, &hnd_src, level, &ctr_src))
2126 /* copy each src printer to a dst printer 1:1,
2127 maybe some values have to be changed though */
2128 d_printf("creating printer: %s\n", printername);
2129 result = cli_spoolss_addprinterex (cli_dst, mem_ctx, level, &ctr_src);
2131 if (W_ERROR_IS_OK(result))
2132 d_printf ("printer [%s] successfully added.\n", printername);
2133 else if (W_ERROR_V(result) == W_ERROR_V(WERR_PRINTER_ALREADY_EXISTS))
2134 d_printf ("printer [%s] already exists.\n", printername);
2136 printf ("could not create printer\n");
2140 /* close printer handles here */
2142 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
2143 got_hnd_src = False;
2147 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
2148 got_hnd_dst = False;
2152 nt_status = NT_STATUS_OK;
2156 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
2159 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
2161 if (got_dst_spoolss_pipe) {
2162 cli_nt_session_close(cli_dst);
2163 cli_shutdown(cli_dst);
2170 * Migrate Printer-Settings from a src server to the dst server
2171 * (for this to work, printers and drivers already have to be migrated earlier)
2173 * All parameters are provided by the run_rpc_command function, except for
2174 * argc, argv which are passed through.
2176 * @param domain_sid The domain sid aquired from the remote server
2177 * @param cli A cli_state connected to the server.
2178 * @param mem_ctx Talloc context, destoyed on compleation of the function.
2179 * @param argc Standard main() style argc
2180 * @param argv Standard main() style argv. Initial components are already
2183 * @return Normal NTSTATUS return.
2185 NTSTATUS rpc_printer_migrate_settings_internals(const DOM_SID *domain_sid, const char *domain_name,
2186 struct cli_state *cli, TALLOC_CTX *mem_ctx,
2187 int argc, const char **argv)
2190 /* FIXME: Here the nightmare begins */
2193 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
2194 uint32 i = 0, p = 0, j = 0;
2195 uint32 num_printers, val_needed, data_needed;
2197 pstring printername = "", sharename = "";
2198 BOOL got_hnd_src = False;
2199 BOOL got_hnd_dst = False;
2200 BOOL got_dst_spoolss_pipe = False;
2201 POLICY_HND hnd_src, hnd_dst;
2202 PRINTER_INFO_CTR ctr_enum, ctr_dst, ctr_dst_publish;
2204 struct cli_state *cli_dst = NULL;
2205 char *devicename = NULL, *unc_name = NULL, *url = NULL;
2208 const char *keyname = NULL;
2209 uint16 *keylist = NULL, *curkey;
2211 ZERO_STRUCT(ctr_enum);
2213 DEBUG(3,("copying printer settings\n"));
2215 /* connect destination PI_SPOOLSS */
2216 nt_status = connect_pipe(&cli_dst, PI_SPOOLSS, &got_dst_spoolss_pipe);
2217 if (!NT_STATUS_IS_OK(nt_status))
2221 /* enum src printers */
2222 if (!get_printer_info(cli, mem_ctx, level, argc, argv, &num_printers, &ctr_enum)) {
2223 nt_status = NT_STATUS_UNSUCCESSFUL;
2227 if (!num_printers) {
2228 printf ("no printers found on server.\n");
2229 nt_status = NT_STATUS_OK;
2234 /* needed for dns-strings in regkeys */
2235 get_mydnsfullname(longname);
2237 /* do something for all printers */
2238 for (i = 0; i < num_printers; i++) {
2240 /* do some initialization */
2241 rpcstr_pull(printername, ctr_enum.printers_2[i].printername.buffer,
2242 sizeof(printername), -1, STR_TERMINATE);
2243 rpcstr_pull(sharename, ctr_enum.printers_2[i].sharename.buffer,
2244 sizeof(sharename), -1, STR_TERMINATE);
2246 /* we can reset NT_STATUS here because we do not
2247 get any real NT_STATUS-codes anymore from now on */
2248 nt_status = NT_STATUS_UNSUCCESSFUL;
2250 d_printf("migrating printer settings for: [%s] / [%s]\n",
2251 printername, sharename);
2254 /* open src printer handle */
2255 if (!net_spoolss_open_printer_ex(cli, mem_ctx, sharename,
2256 MAXIMUM_ALLOWED_ACCESS, cli->user_name, &hnd_src))
2262 /* open dst printer handle */
2263 if (!net_spoolss_open_printer_ex(cli_dst, mem_ctx, sharename,
2264 PRINTER_ALL_ACCESS, cli_dst->user_name, &hnd_dst))
2270 /* check for existing dst printer */
2271 if (!net_spoolss_getprinter(cli_dst, mem_ctx, &hnd_dst,
2276 /* STEP 1: COPY DEVICE-MODE and other
2277 PRINTER_INFO_2-attributes
2280 ctr_dst.printers_2 = &ctr_enum.printers_2[i];
2282 /* why is the port always disconnected when the printer
2283 is correctly installed (incl. driver ???) */
2284 init_unistr( &ctr_dst.printers_2->portname, SAMBA_PRINTER_PORT_NAME);
2286 /* check if printer is published */
2287 if (ctr_enum.printers_2[i].attributes & PRINTER_ATTRIBUTE_PUBLISHED) {
2289 /* check for existing dst printer */
2290 if (!net_spoolss_getprinter(cli_dst, mem_ctx, &hnd_dst, 7, &ctr_dst_publish))
2293 ctr_dst_publish.printers_7->action = SPOOL_DS_PUBLISH;
2295 /* ignore False from setprinter due to WERR_IO_PENDING */
2296 net_spoolss_setprinter(cli_dst, mem_ctx, &hnd_dst, 7, &ctr_dst_publish);
2298 DEBUG(3,("republished printer\n"));
2301 /* copy devmode (info level 2) */
2302 ctr_dst.printers_2->devmode = talloc_memdup(mem_ctx,
2303 ctr_enum.printers_2[i].devmode, sizeof(DEVICEMODE));
2305 /* do not copy security descriptor (we have another command for that) */
2306 ctr_dst.printers_2->secdesc = NULL;
2309 /* devmode->devicename is possibly broken at the moment for all
2310 strlen(longprinternames) > MAXDEVICENAME (that is 32 chars)
2311 this fires up thousands of safe_strncpy-debug0-messages
2313 TODO: tell jerry, jra, etc. again.
2317 if (asprintf(&devicename, "\\\\%s\\%s", longname, printername) < 0) {
2318 nt_status = NT_STATUS_NO_MEMORY;
2322 init_unistr(&ctr_dst.printers_2->devmode->devicename, devicename);
2324 if (!net_spoolss_setprinter(cli_dst, mem_ctx, &hnd_dst,
2328 DEBUGADD(1,("\tSetPrinter of DEVICEMODE succeeded\n"));
2332 /* STEP 2: COPY REGISTRY VALUES */
2334 /* please keep in mind that samba parse_spools gives horribly
2335 crippled results when used to cli_spoolss_enumprinterdataex
2337 FIXME: IIRC I've seen it too on a win2k-server
2340 /* enumerate data on src handle */
2341 result = cli_spoolss_enumprinterdata(cli, mem_ctx, &hnd_src, p, 0, 0,
2342 &val_needed, &data_needed, NULL);
2344 /* loop for all printerdata */
2345 while (W_ERROR_IS_OK(result)) {
2347 REGISTRY_VALUE value;
2349 result = cli_spoolss_enumprinterdata(
2350 cli, mem_ctx, &hnd_src, p++, val_needed,
2351 data_needed, 0, 0, &value);
2353 /* loop for all reg_keys */
2354 if (W_ERROR_IS_OK(result)) {
2358 display_reg_value(NULL, value);
2361 if (!net_spoolss_setprinterdata(cli_dst, mem_ctx,
2365 DEBUGADD(1,("\tSetPrinterData of [%s] succeeded\n",
2370 /* STEP 3: COPY SUBKEY VALUES */
2372 /* here we need to enum all printer_keys and then work
2373 on the result with enum_printer_key_ex. nt4 does not
2374 respond to enumprinterkey, win2k does, so continue
2375 in case of an error */
2377 if (!net_spoolss_enumprinterkey(cli, mem_ctx, &hnd_src, keyname, &keylist)) {
2378 printf("got no key-data\n");
2383 /* work on a list of printer keys
2384 each key has to be enumerated to get all required
2385 information. information is then set via setprinterdataex-calls */
2387 if (keylist == NULL)
2391 while (*curkey != 0) {
2394 rpcstr_pull(subkey, curkey, sizeof(subkey), -1, STR_TERMINATE);
2396 curkey += strlen(subkey) + 1;
2398 /* enumerate all src subkeys */
2399 if (!net_spoolss_enumprinterdataex(cli, mem_ctx, 0,
2404 for (j=0; j < reg_ctr.num_values; j++) {
2406 REGISTRY_VALUE value;
2409 /* although samba replies with sane data in most cases we
2410 should try to avoid writing wrong registry data */
2412 if (strequal(reg_ctr.values[j]->valuename, SPOOL_REG_PORTNAME) ||
2413 strequal(reg_ctr.values[j]->valuename, SPOOL_REG_UNCNAME) ||
2414 strequal(reg_ctr.values[j]->valuename, SPOOL_REG_URL) ||
2415 strequal(reg_ctr.values[j]->valuename, SPOOL_REG_SHORTSERVERNAME) ||
2416 strequal(reg_ctr.values[j]->valuename, SPOOL_REG_SERVERNAME)) {
2418 if (strequal(reg_ctr.values[j]->valuename, SPOOL_REG_PORTNAME)) {
2420 /* although windows uses a multi-sz, we use a sz */
2421 init_unistr2(&data, SAMBA_PRINTER_PORT_NAME, UNI_STR_TERMINATE);
2422 fstrcpy(value.valuename, SPOOL_REG_PORTNAME);
2425 if (strequal(reg_ctr.values[j]->valuename, SPOOL_REG_UNCNAME)) {
2427 if (asprintf(&unc_name, "\\\\%s\\%s", longname, sharename) < 0) {
2428 nt_status = NT_STATUS_NO_MEMORY;
2431 init_unistr2(&data, unc_name, UNI_STR_TERMINATE);
2432 fstrcpy(value.valuename, SPOOL_REG_UNCNAME);
2435 if (strequal(reg_ctr.values[j]->valuename, SPOOL_REG_URL)) {
2440 /* FIXME: should we really do that ??? */
2441 if (asprintf(&url, "http://%s:631/printers/%s", longname, sharename) < 0) {
2442 nt_status = NT_STATUS_NO_MEMORY;
2445 init_unistr2(&data, url, UNI_STR_TERMINATE);
2446 fstrcpy(value.valuename, SPOOL_REG_URL);
2450 if (strequal(reg_ctr.values[j]->valuename, SPOOL_REG_SERVERNAME)) {
2452 init_unistr2(&data, longname, UNI_STR_TERMINATE);
2453 fstrcpy(value.valuename, SPOOL_REG_SERVERNAME);
2456 if (strequal(reg_ctr.values[j]->valuename, SPOOL_REG_SHORTSERVERNAME)) {
2458 init_unistr2(&data, global_myname(), UNI_STR_TERMINATE);
2459 fstrcpy(value.valuename, SPOOL_REG_SHORTSERVERNAME);
2462 value.type = REG_SZ;
2463 value.size = data.uni_str_len * 2;
2464 value.data_p = talloc_memdup(mem_ctx, data.buffer, value.size);
2467 display_reg_value(subkey, value);
2469 /* here we have to set all subkeys on the dst server */
2470 if (!net_spoolss_setprinterdataex(cli_dst, mem_ctx, &hnd_dst,
2477 display_reg_value(subkey, *(reg_ctr.values[j]));
2479 /* here we have to set all subkeys on the dst server */
2480 if (!net_spoolss_setprinterdataex(cli_dst, mem_ctx, &hnd_dst,
2481 subkey, reg_ctr.values[j]))
2486 DEBUGADD(1,("\tSetPrinterDataEx of key [%s\\%s] succeeded\n",
2487 subkey, reg_ctr.values[j]->valuename));
2491 regval_ctr_destroy(®_ctr);
2496 /* close printer handles here */
2498 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
2499 got_hnd_src = False;
2503 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
2504 got_hnd_dst = False;
2509 nt_status = NT_STATUS_OK;
2512 SAFE_FREE(devicename);
2514 SAFE_FREE(unc_name);
2517 cli_spoolss_close_printer(cli, mem_ctx, &hnd_src);
2520 cli_spoolss_close_printer(cli_dst, mem_ctx, &hnd_dst);
2522 if (got_dst_spoolss_pipe) {
2523 cli_nt_session_close(cli_dst);
2524 cli_shutdown(cli_dst);