2 Samba Unix/Linux SMB client library
3 Distributed SMB/CIFS Server Management Utility
4 Local printing tdb migration interface
6 Copyright (C) Guenther Deschner 2010
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "utils/net.h"
24 #include "librpc/gen_ndr/ndr_ntprinting.h"
25 #include "librpc/gen_ndr/ndr_spoolss_c.h"
26 #include "rpc_client/cli_spoolss.h"
27 #include "../libcli/security/security.h"
28 #include "../librpc/gen_ndr/ndr_security.h"
30 #define FORMS_PREFIX "FORMS/"
31 #define DRIVERS_PREFIX "DRIVERS/"
32 #define PRINTERS_PREFIX "PRINTERS/"
33 #define SECDESC_PREFIX "SECDESC/"
35 static void dump_form(TALLOC_CTX
*mem_ctx
,
40 enum ndr_err_code ndr_err
;
43 struct ntprinting_form r
;
45 printf("found form: %s\n", key_name
);
47 blob
= data_blob_const(data
, length
);
51 ndr_err
= ndr_pull_struct_blob(&blob
, mem_ctx
, &r
,
52 (ndr_pull_flags_fn_t
)ndr_pull_ntprinting_form
);
53 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
54 d_fprintf(stderr
, _("form pull failed: %s\n"),
59 s
= NDR_PRINT_STRUCT_STRING(mem_ctx
, ntprinting_form
, &r
);
65 static void dump_driver(TALLOC_CTX
*mem_ctx
,
70 enum ndr_err_code ndr_err
;
73 struct ntprinting_driver r
;
75 printf("found driver: %s\n", key_name
);
77 blob
= data_blob_const(data
, length
);
81 ndr_err
= ndr_pull_struct_blob(&blob
, mem_ctx
, &r
,
82 (ndr_pull_flags_fn_t
)ndr_pull_ntprinting_driver
);
83 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
84 d_fprintf(stderr
, _("driver pull failed: %s\n"),
89 s
= NDR_PRINT_STRUCT_STRING(mem_ctx
, ntprinting_driver
, &r
);
95 static void dump_printer(TALLOC_CTX
*mem_ctx
,
100 enum ndr_err_code ndr_err
;
103 struct ntprinting_printer r
;
105 printf("found printer: %s\n", key_name
);
107 blob
= data_blob_const(data
, length
);
111 ndr_err
= ndr_pull_struct_blob(&blob
, mem_ctx
, &r
,
112 (ndr_pull_flags_fn_t
)ndr_pull_ntprinting_printer
);
113 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
114 d_fprintf(stderr
, _("printer pull failed: %s\n"),
115 ndr_errstr(ndr_err
));
119 s
= NDR_PRINT_STRUCT_STRING(mem_ctx
, ntprinting_printer
, &r
);
125 static void dump_sd(TALLOC_CTX
*mem_ctx
,
126 const char *key_name
,
130 enum ndr_err_code ndr_err
;
133 struct sec_desc_buf r
;
135 printf("found security descriptor: %s\n", key_name
);
137 blob
= data_blob_const(data
, length
);
141 ndr_err
= ndr_pull_struct_blob(&blob
, mem_ctx
, &r
,
142 (ndr_pull_flags_fn_t
)ndr_pull_sec_desc_buf
);
143 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
144 d_fprintf(stderr
, _("security descriptor pull failed: %s\n"),
145 ndr_errstr(ndr_err
));
149 s
= NDR_PRINT_STRUCT_STRING(mem_ctx
, sec_desc_buf
, &r
);
156 static int net_printing_dump(struct net_context
*c
, int argc
,
160 TALLOC_CTX
*ctx
= talloc_stackframe();
162 TDB_DATA kbuf
, newkey
, dbuf
;
164 if (argc
< 1 || c
->display_usage
) {
165 d_fprintf(stderr
, "%s\nnet printing dump <file.tdb>\n",
170 tdb
= tdb_open_log(argv
[0], 0, TDB_DEFAULT
, O_RDONLY
, 0600);
172 d_fprintf(stderr
, _("failed to open tdb file: %s\n"), argv
[0]);
176 for (kbuf
= tdb_firstkey(tdb
);
178 newkey
= tdb_nextkey(tdb
, kbuf
), free(kbuf
.dptr
), kbuf
=newkey
)
180 dbuf
= tdb_fetch(tdb
, kbuf
);
185 if (strncmp((const char *)kbuf
.dptr
, FORMS_PREFIX
, strlen(FORMS_PREFIX
)) == 0) {
186 dump_form(ctx
, (const char *)kbuf
.dptr
+strlen(FORMS_PREFIX
), dbuf
.dptr
, dbuf
.dsize
);
187 SAFE_FREE(dbuf
.dptr
);
191 if (strncmp((const char *)kbuf
.dptr
, DRIVERS_PREFIX
, strlen(DRIVERS_PREFIX
)) == 0) {
192 dump_driver(ctx
, (const char *)kbuf
.dptr
+strlen(DRIVERS_PREFIX
), dbuf
.dptr
, dbuf
.dsize
);
193 SAFE_FREE(dbuf
.dptr
);
197 if (strncmp((const char *)kbuf
.dptr
, PRINTERS_PREFIX
, strlen(PRINTERS_PREFIX
)) == 0) {
198 dump_printer(ctx
, (const char *)kbuf
.dptr
+strlen(PRINTERS_PREFIX
), dbuf
.dptr
, dbuf
.dsize
);
199 SAFE_FREE(dbuf
.dptr
);
203 if (strncmp((const char *)kbuf
.dptr
, SECDESC_PREFIX
, strlen(SECDESC_PREFIX
)) == 0) {
204 dump_sd(ctx
, (const char *)kbuf
.dptr
+strlen(SECDESC_PREFIX
), dbuf
.dptr
, dbuf
.dsize
);
205 SAFE_FREE(dbuf
.dptr
);
218 static NTSTATUS
migrate_form(TALLOC_CTX
*mem_ctx
,
219 struct rpc_pipe_client
*pipe_hnd
,
220 const char *key_name
,
224 struct dcerpc_binding_handle
*b
= pipe_hnd
->binding_handle
;
225 struct policy_handle hnd
;
226 enum ndr_err_code ndr_err
;
227 struct ntprinting_form r
;
228 union spoolss_AddFormInfo f
;
229 struct spoolss_AddFormInfo1 f1
;
234 blob
= data_blob_const(data
, length
);
238 ndr_err
= ndr_pull_struct_blob(&blob
, mem_ctx
, &r
,
239 (ndr_pull_flags_fn_t
)ndr_pull_ntprinting_form
);
240 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
241 d_fprintf(stderr
, _("form pull failed: %s\n"),
242 ndr_errstr(ndr_err
));
243 return NT_STATUS_NO_MEMORY
;
246 /* Don't migrate builtin forms */
247 if (r
.flag
== SPOOLSS_FORM_BUILTIN
) {
251 d_printf(_("Migrating Form: %s\n"), key_name
);
253 result
= rpccli_spoolss_openprinter_ex(pipe_hnd
,
255 pipe_hnd
->srv_name_slash
,
256 MAXIMUM_ALLOWED_ACCESS
,
258 if (!W_ERROR_IS_OK(result
)) {
259 d_fprintf(stderr
, _("OpenPrinter(%s) failed: %s\n"),
260 pipe_hnd
->srv_name_slash
, win_errstr(result
));
261 return werror_to_ntstatus(result
);
264 f1
.form_name
= key_name
;
267 f1
.size
.width
= r
.width
;
268 f1
.size
.height
= r
.length
;
271 f1
.area
.right
= r
.right
;
272 f1
.area
.bottom
= r
.bottom
;
273 f1
.area
.left
= r
.left
;
277 status
= dcerpc_spoolss_AddForm(b
,
283 if (!NT_STATUS_IS_OK(status
)) {
284 d_printf(_("\tAddForm(%s) refused -- %s.\n"),
285 f
.info1
->form_name
, nt_errstr(status
));
286 } else if (!W_ERROR_IS_OK(result
)) {
287 d_printf(_("\tAddForm(%s) refused -- %s.\n"),
288 f
.info1
->form_name
, win_errstr(result
));
289 status
= werror_to_ntstatus(result
);
292 dcerpc_spoolss_ClosePrinter(b
, mem_ctx
, &hnd
, &result
);
297 static NTSTATUS
migrate_driver(TALLOC_CTX
*mem_ctx
,
298 struct rpc_pipe_client
*pipe_hnd
,
299 const char *key_name
,
303 struct dcerpc_binding_handle
*b
= pipe_hnd
->binding_handle
;
304 enum ndr_err_code ndr_err
;
305 struct ntprinting_driver r
;
306 struct spoolss_AddDriverInfoCtr d
;
307 struct spoolss_AddDriverInfo3 d3
;
308 struct spoolss_StringArray a
;
313 blob
= data_blob_const(data
, length
);
317 ndr_err
= ndr_pull_struct_blob(&blob
, mem_ctx
, &r
,
318 (ndr_pull_flags_fn_t
)ndr_pull_ntprinting_driver
);
319 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
320 d_fprintf(stderr
, _("driver pull failed: %s\n"),
321 ndr_errstr(ndr_err
));
322 return NT_STATUS_NO_MEMORY
;
325 d_printf(_("Migrating Printer Driver: %s\n"), key_name
);
330 a
.string
= r
.dependent_files
;
332 d3
.architecture
= r
.environment
;
333 d3
.config_file
= r
.configfile
;
334 d3
.data_file
= r
.datafile
;
335 d3
.default_datatype
= r
.defaultdatatype
;
336 d3
.dependent_files
= &a
;
337 d3
.driver_path
= r
.driverpath
;
338 d3
.help_file
= r
.helpfile
;
339 d3
.monitor_name
= r
.monitorname
;
340 d3
.driver_name
= r
.name
;
341 d3
.version
= r
.version
;
346 status
= dcerpc_spoolss_AddPrinterDriver(b
,
351 if (!NT_STATUS_IS_OK(status
)) {
352 d_printf(_("\tAddDriver driver: [%s] refused -- %s.\n"),
353 d3
.driver_name
, nt_errstr(status
));
354 } else if (!W_ERROR_IS_OK(result
)) {
355 d_printf(_("\tAddDriver driver: [%s] refused -- %s.\n"),
356 d3
.driver_name
, win_errstr(result
));
357 status
= werror_to_ntstatus(result
);
363 static NTSTATUS
migrate_printer(TALLOC_CTX
*mem_ctx
,
364 struct rpc_pipe_client
*pipe_hnd
,
365 const char *key_name
,
369 struct dcerpc_binding_handle
*b
= pipe_hnd
->binding_handle
;
370 struct policy_handle hnd
;
371 enum ndr_err_code ndr_err
;
372 struct ntprinting_printer r
;
373 struct spoolss_SetPrinterInfo2 info2
;
374 struct spoolss_DeviceMode dm
;
375 struct spoolss_SetPrinterInfoCtr info_ctr
;
376 struct spoolss_DevmodeContainer devmode_ctr
;
377 struct sec_desc_buf secdesc_ctr
;
383 if (strequal(key_name
, "printers")) {
387 blob
= data_blob_const(data
, length
);
391 ndr_err
= ndr_pull_struct_blob(&blob
, mem_ctx
, &r
,
392 (ndr_pull_flags_fn_t
) ndr_pull_ntprinting_printer
);
393 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
394 d_fprintf(stderr
, _("printer pull failed: %s\n"),
395 ndr_errstr(ndr_err
));
396 return NT_STATUS_NO_MEMORY
;
399 d_printf(_("Migrating Printer: %s\n"), key_name
);
401 result
= rpccli_spoolss_openprinter_ex(pipe_hnd
,
404 MAXIMUM_ALLOWED_ACCESS
,
406 if (!W_ERROR_IS_OK(result
)) {
407 d_fprintf(stderr
, _("OpenPrinter(%s) failed: %s\n"),
408 key_name
, win_errstr(result
));
409 return werror_to_ntstatus(result
);
412 /* Create printer info level 2 */
414 ZERO_STRUCT(devmode_ctr
);
415 ZERO_STRUCT(secdesc_ctr
);
417 info2
.attributes
= r
.info
.attributes
;
418 info2
.averageppm
= r
.info
.averageppm
;
419 info2
.cjobs
= r
.info
.cjobs
;
420 info2
.comment
= r
.info
.comment
;
421 info2
.datatype
= r
.info
.datatype
;
422 info2
.defaultpriority
= r
.info
.default_priority
;
423 info2
.drivername
= r
.info
.drivername
;
424 info2
.location
= r
.info
.location
;
425 info2
.parameters
= r
.info
.parameters
;
426 info2
.portname
= r
.info
.portname
;
427 info2
.printername
= r
.info
.printername
;
428 info2
.printprocessor
= r
.info
.printprocessor
;
429 info2
.priority
= r
.info
.priority
;
430 info2
.sepfile
= r
.info
.sepfile
;
431 info2
.sharename
= r
.info
.sharename
;
432 info2
.starttime
= r
.info
.starttime
;
433 info2
.status
= r
.info
.status
;
434 info2
.untiltime
= r
.info
.untiltime
;
436 /* Create Device Mode */
437 if (r
.devmode
!= NULL
) {
440 dm
.bitsperpel
= r
.devmode
->bitsperpel
;
441 dm
.collate
= r
.devmode
->collate
;
442 dm
.color
= r
.devmode
->color
;
443 dm
.copies
= r
.devmode
->copies
;
444 dm
.defaultsource
= r
.devmode
->defaultsource
;
445 dm
.devicename
= r
.devmode
->devicename
;
446 dm
.displayflags
= r
.devmode
->displayflags
;
447 dm
.displayfrequency
= r
.devmode
->displayfrequency
;
448 dm
.dithertype
= r
.devmode
->dithertype
;
449 dm
.driverversion
= r
.devmode
->driverversion
;
450 dm
.duplex
= r
.devmode
->duplex
;
451 dm
.fields
= r
.devmode
->fields
;
452 dm
.formname
= r
.devmode
->formname
;
453 dm
.icmintent
= r
.devmode
->icmintent
;
454 dm
.icmmethod
= r
.devmode
->icmmethod
;
455 dm
.logpixels
= r
.devmode
->logpixels
;
456 dm
.mediatype
= r
.devmode
->mediatype
;
457 dm
.orientation
= r
.devmode
->orientation
;
458 dm
.panningheight
= r
.devmode
->pelsheight
;
459 dm
.panningwidth
= r
.devmode
->panningwidth
;
460 dm
.paperlength
= r
.devmode
->paperlength
;
461 dm
.papersize
= r
.devmode
->papersize
;
462 dm
.paperwidth
= r
.devmode
->paperwidth
;
463 dm
.pelsheight
= r
.devmode
->pelsheight
;
464 dm
.pelswidth
= r
.devmode
->pelswidth
;
465 dm
.printquality
= r
.devmode
->printquality
;
466 dm
.scale
= r
.devmode
->scale
;
467 dm
.specversion
= r
.devmode
->specversion
;
468 dm
.ttoption
= r
.devmode
->ttoption
;
469 dm
.yresolution
= r
.devmode
->yresolution
;
471 if (r
.devmode
->nt_dev_private
!= NULL
) {
472 dm
.driverextra_data
.data
= r
.devmode
->nt_dev_private
->data
;
473 dm
.driverextra_data
.length
= r
.devmode
->nt_dev_private
->length
;
474 dm
.__driverextra_length
= r
.devmode
->nt_dev_private
->length
;
477 devmode_ctr
.devmode
= &dm
;
479 info2
.devmode_ptr
= 1;
482 info_ctr
.info
.info2
= &info2
;
485 status
= dcerpc_spoolss_SetPrinter(b
,
493 if (!NT_STATUS_IS_OK(status
)) {
494 d_printf(_("\tSetPrinter(%s) level 2 refused -- %s.\n"),
495 key_name
, nt_errstr(status
));
497 } else if (!W_ERROR_IS_OK(result
)) {
498 d_printf(_("\tSetPrinter(%s) level 2 refused -- %s.\n"),
499 key_name
, win_errstr(result
));
500 status
= werror_to_ntstatus(result
);
504 /* migrate printerdata */
505 for (j
= 0; j
< r
.count
; j
++) {
509 if (r
.printer_data
[j
].type
== REG_NONE
) {
513 keyname
= CONST_DISCARD(char *, r
.printer_data
[j
].name
);
514 valuename
= strchr(keyname
, '\\');
515 if (valuename
== NULL
) {
522 printf(" data: %s\\%s\n", keyname
, valuename
);
524 status
= dcerpc_spoolss_SetPrinterDataEx(b
,
529 r
.printer_data
[j
].type
,
530 r
.printer_data
[j
].data
.data
,
531 r
.printer_data
[j
].data
.length
,
533 if (!NT_STATUS_IS_OK(status
)) {
534 d_printf(_("\tSetPrinterDataEx: printer [%s], keyname [%s], valuename [%s] refused -- %s.\n"),
535 key_name
, keyname
, valuename
, nt_errstr(status
));
537 } else if (!W_ERROR_IS_OK(result
)) {
538 d_printf(_("\tSetPrinterDataEx: printer [%s], keyname [%s], valuename [%s] refused -- %s.\n"),
539 key_name
, keyname
, valuename
, win_errstr(result
));
540 status
= werror_to_ntstatus(result
);
546 dcerpc_spoolss_ClosePrinter(b
, mem_ctx
, &hnd
, &result
);
551 static NTSTATUS
migrate_secdesc(TALLOC_CTX
*mem_ctx
,
552 struct rpc_pipe_client
*pipe_hnd
,
553 const char *key_name
,
557 struct dcerpc_binding_handle
*b
= pipe_hnd
->binding_handle
;
558 struct policy_handle hnd
;
559 enum ndr_err_code ndr_err
;
560 struct sec_desc_buf secdesc_ctr
;
561 struct spoolss_SetPrinterInfo3 info3
;
562 struct spoolss_SetPrinterInfoCtr info_ctr
;
563 struct spoolss_DevmodeContainer devmode_ctr
;
568 if (strequal(key_name
, "printers")) {
572 blob
= data_blob_const(data
, length
);
574 ZERO_STRUCT(secdesc_ctr
);
576 ndr_err
= ndr_pull_struct_blob(&blob
, mem_ctx
, &secdesc_ctr
,
577 (ndr_pull_flags_fn_t
)ndr_pull_sec_desc_buf
);
578 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
579 d_fprintf(stderr
, _("security descriptor pull failed: %s\n"),
580 ndr_errstr(ndr_err
));
581 return NT_STATUS_NO_MEMORY
;
584 d_printf(_("Migrating Security Descriptor: %s\n"), key_name
);
586 result
= rpccli_spoolss_openprinter_ex(pipe_hnd
,
589 MAXIMUM_ALLOWED_ACCESS
,
591 if (!W_ERROR_IS_OK(result
)) {
592 d_fprintf(stderr
, _("\tOpenPrinter(%s) failed: %s\n"),
593 key_name
, win_errstr(result
));
594 return werror_to_ntstatus(result
);
597 ZERO_STRUCT(devmode_ctr
);
599 info3
.sec_desc_ptr
= 1;
601 info_ctr
.info
.info3
= &info3
;
604 status
= dcerpc_spoolss_SetPrinter(b
,
612 if (!NT_STATUS_IS_OK(status
)) {
613 d_printf(_("\tSetPrinter(%s) level 3 refused -- %s.\n"),
614 key_name
, nt_errstr(status
));
615 } else if (!W_ERROR_IS_OK(result
)) {
616 d_printf(_("\tSetPrinter(%s) level 3 refused -- %s.\n"),
617 key_name
, win_errstr(result
));
618 status
= werror_to_ntstatus(result
);
621 dcerpc_spoolss_ClosePrinter(b
, mem_ctx
, &hnd
, &result
);
626 static NTSTATUS
printing_migrate_internal(struct net_context
*c
,
627 const struct dom_sid
*domain_sid
,
628 const char *domain_name
,
629 struct cli_state
*cli
,
630 struct rpc_pipe_client
*pipe_hnd
,
637 TDB_DATA kbuf
, newkey
, dbuf
;
640 tmp_ctx
= talloc_new(mem_ctx
);
641 if (tmp_ctx
== NULL
) {
642 return NT_STATUS_NO_MEMORY
;
645 tdb
= tdb_open_log(argv
[0], 0, TDB_DEFAULT
, O_RDONLY
, 0600);
647 d_fprintf(stderr
, _("failed to open tdb file: %s\n"), argv
[0]);
648 status
= NT_STATUS_NO_SUCH_FILE
;
652 for (kbuf
= tdb_firstkey(tdb
);
654 newkey
= tdb_nextkey(tdb
, kbuf
), free(kbuf
.dptr
), kbuf
= newkey
)
656 dbuf
= tdb_fetch(tdb
, kbuf
);
661 if (strncmp((const char *) kbuf
.dptr
, FORMS_PREFIX
, strlen(FORMS_PREFIX
)) == 0) {
662 migrate_form(tmp_ctx
,
664 (const char *) kbuf
.dptr
+ strlen(FORMS_PREFIX
),
667 SAFE_FREE(dbuf
.dptr
);
671 if (strncmp((const char *) kbuf
.dptr
, DRIVERS_PREFIX
, strlen(DRIVERS_PREFIX
)) == 0) {
672 migrate_driver(tmp_ctx
,
674 (const char *) kbuf
.dptr
+ strlen(DRIVERS_PREFIX
),
677 SAFE_FREE(dbuf
.dptr
);
681 if (strncmp((const char *) kbuf
.dptr
, PRINTERS_PREFIX
, strlen(PRINTERS_PREFIX
)) == 0) {
682 migrate_printer(tmp_ctx
,
684 (const char *) kbuf
.dptr
+ strlen(PRINTERS_PREFIX
),
687 SAFE_FREE(dbuf
.dptr
);
691 if (strncmp((const char *) kbuf
.dptr
, SECDESC_PREFIX
, strlen(SECDESC_PREFIX
)) == 0) {
692 migrate_secdesc(tmp_ctx
,
694 (const char *) kbuf
.dptr
+ strlen(SECDESC_PREFIX
),
697 SAFE_FREE(dbuf
.dptr
);
703 status
= NT_STATUS_OK
;
706 talloc_free(tmp_ctx
);
710 static int net_printing_migrate(struct net_context
*c
,
714 if (argc
< 1 || c
->display_usage
) {
716 "net printing migrate <file.tdb>\n"
719 _("Migrate tdb printing files to new storage"));
723 return run_rpc_command(c
,
725 &ndr_table_spoolss
.syntax_id
,
727 printing_migrate_internal
,
732 * 'net printing' entrypoint.
733 * @param argc Standard main() style argc.
734 * @param argv Standard main() style argv. Initial components are already
738 int net_printing(struct net_context
*c
, int argc
, const char **argv
)
742 struct functable func
[] = {
747 N_("Dump printer databases"),
748 N_("net printing dump\n"
749 " Dump tdb printing file")
754 net_printing_migrate
,
755 NET_TRANSPORT_LOCAL
| NET_TRANSPORT_RPC
,
756 N_("Migrate printer databases"),
757 N_("net printing migrate\n"
758 " Migrate tdb printing files to new storage")
761 { NULL
, NULL
, 0, NULL
, NULL
}
764 ret
= net_run_function(c
, argc
, argv
, "net printing", func
);