?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:registry: extract the reg_cachehook prototypes into their own header.
[Samba/gebeck_regimport.git] / source3 / utils / net_printing.c
blobc7a262433eff5c2f20a6100b82aba76e1c9362e0
1 /*
2 Samba Unix/Linux SMB client library
3 Distributed SMB/CIFS Server Management Utility
4 Local printing tdb migration interface
5
6 Copyright (C) Guenther Deschner 2010
7
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.
12
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.
17
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/>.
20 */
21
22 #include "includes.h"
23 #include "utils/net.h"
24 #include "librpc/gen_ndr/ndr_ntprinting.h"
25 #include "librpc/gen_ndr/cli_spoolss.h"
26 #include "rpc_client/cli_spoolss.h"
27
28 #define FORMS_PREFIX "FORMS/"
29 #define DRIVERS_PREFIX "DRIVERS/"
30 #define PRINTERS_PREFIX "PRINTERS/"
31 #define SECDESC_PREFIX "SECDESC/"
32
33 static void dump_form(TALLOC_CTX *mem_ctx,
34 const char *key_name,
35 unsigned char *data,
36 size_t length)
37 {
38 enum ndr_err_code ndr_err;
39 DATA_BLOB blob;
40 char *s;
41 struct ntprinting_form r;
42
43 printf("found form: %s\n", key_name);
44
45 blob = data_blob_const(data, length);
46
47 ZERO_STRUCT(r);
48
49 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
50 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_form);
51 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
52 d_fprintf(stderr, _("form pull failed: %s\n"),
53 ndr_errstr(ndr_err));
54 return;
55 }
56
57 s = NDR_PRINT_STRUCT_STRING(mem_ctx, ntprinting_form, &r);
58 if (s) {
59 printf("%s\n", s);
60 }
61 }
62
63 static void dump_driver(TALLOC_CTX *mem_ctx,
64 const char *key_name,
65 unsigned char *data,
66 size_t length)
67 {
68 enum ndr_err_code ndr_err;
69 DATA_BLOB blob;
70 char *s;
71 struct ntprinting_driver r;
72
73 printf("found driver: %s\n", key_name);
74
75 blob = data_blob_const(data, length);
76
77 ZERO_STRUCT(r);
78
79 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
80 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_driver);
81 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
82 d_fprintf(stderr, _("driver pull failed: %s\n"),
83 ndr_errstr(ndr_err));
84 return;
85 }
86
87 s = NDR_PRINT_STRUCT_STRING(mem_ctx, ntprinting_driver, &r);
88 if (s) {
89 printf("%s\n", s);
90 }
91 }
92
93 static void dump_printer(TALLOC_CTX *mem_ctx,
94 const char *key_name,
95 unsigned char *data,
96 size_t length)
97 {
98 enum ndr_err_code ndr_err;
99 DATA_BLOB blob;
100 char *s;
101 struct ntprinting_printer r;
102
103 printf("found printer: %s\n", key_name);
104
105 blob = data_blob_const(data, length);
106
107 ZERO_STRUCT(r);
108
109 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
110 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_printer);
111 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
112 d_fprintf(stderr, _("printer pull failed: %s\n"),
113 ndr_errstr(ndr_err));
114 return;
115 }
116
117 s = NDR_PRINT_STRUCT_STRING(mem_ctx, ntprinting_printer, &r);
118 if (s) {
119 printf("%s\n", s);
120 }
121 }
122
123 static void dump_sd(TALLOC_CTX *mem_ctx,
124 const char *key_name,
125 unsigned char *data,
126 size_t length)
127 {
128 enum ndr_err_code ndr_err;
129 DATA_BLOB blob;
130 char *s;
131 struct sec_desc_buf r;
132
133 printf("found security descriptor: %s\n", key_name);
134
135 blob = data_blob_const(data, length);
136
137 ZERO_STRUCT(r);
138
139 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
140 (ndr_pull_flags_fn_t)ndr_pull_sec_desc_buf);
141 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
142 d_fprintf(stderr, _("security descriptor pull failed: %s\n"),
143 ndr_errstr(ndr_err));
144 return;
145 }
146
147 s = NDR_PRINT_STRUCT_STRING(mem_ctx, sec_desc_buf, &r);
148 if (s) {
149 printf("%s\n", s);
150 }
151 }
152
153
154 static int net_printing_dump(struct net_context *c, int argc,
155 const char **argv)
156 {
157 int ret = -1;
158 TALLOC_CTX *ctx = talloc_stackframe();
159 TDB_CONTEXT *tdb;
160 TDB_DATA kbuf, newkey, dbuf;
161
162 if (argc < 1 || c->display_usage) {
163 d_fprintf(stderr, "%s\nnet printing dump <file.tdb>\n",
164 _("Usage:"));
165 goto done;
166 }
167
168 tdb = tdb_open_log(argv[0], 0, TDB_DEFAULT, O_RDONLY, 0600);
169 if (!tdb) {
170 d_fprintf(stderr, _("failed to open tdb file: %s\n"), argv[0]);
171 goto done;
172 }
173
174 for (kbuf = tdb_firstkey(tdb);
175 kbuf.dptr;
176 newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf=newkey)
177 {
178 dbuf = tdb_fetch(tdb, kbuf);
179 if (!dbuf.dptr) {
180 continue;
181 }
182
183 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
184 dump_form(ctx, (const char *)kbuf.dptr+strlen(FORMS_PREFIX), dbuf.dptr, dbuf.dsize);
185 SAFE_FREE(dbuf.dptr);
186 continue;
187 }
188
189 if (strncmp((const char *)kbuf.dptr, DRIVERS_PREFIX, strlen(DRIVERS_PREFIX)) == 0) {
190 dump_driver(ctx, (const char *)kbuf.dptr+strlen(DRIVERS_PREFIX), dbuf.dptr, dbuf.dsize);
191 SAFE_FREE(dbuf.dptr);
192 continue;
193 }
194
195 if (strncmp((const char *)kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
196 dump_printer(ctx, (const char *)kbuf.dptr+strlen(PRINTERS_PREFIX), dbuf.dptr, dbuf.dsize);
197 SAFE_FREE(dbuf.dptr);
198 continue;
199 }
200
201 if (strncmp((const char *)kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
202 dump_sd(ctx, (const char *)kbuf.dptr+strlen(SECDESC_PREFIX), dbuf.dptr, dbuf.dsize);
203 SAFE_FREE(dbuf.dptr);
204 continue;
205 }
206
207 }
208
209 ret = 0;
210
211 done:
212 talloc_free(ctx);
213 return ret;
214 }
215
216 static NTSTATUS migrate_form(TALLOC_CTX *mem_ctx,
217 struct rpc_pipe_client *pipe_hnd,
218 const char *key_name,
219 unsigned char *data,
220 size_t length)
221 {
222 struct policy_handle hnd;
223 enum ndr_err_code ndr_err;
224 struct ntprinting_form r;
225 union spoolss_AddFormInfo f;
226 struct spoolss_AddFormInfo1 f1;
227 DATA_BLOB blob;
228 NTSTATUS status;
229 WERROR result;
230
231 blob = data_blob_const(data, length);
232
233 ZERO_STRUCT(r);
234
235 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
236 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_form);
237 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
238 d_fprintf(stderr, _("form pull failed: %s\n"),
239 ndr_errstr(ndr_err));
240 return NT_STATUS_NO_MEMORY;
241 }
242
243 /* Don't migrate builtin forms */
244 if (r.flag == SPOOLSS_FORM_BUILTIN) {
245 return NT_STATUS_OK;
246 }
247
248 d_printf(_("Migrating Form: %s\n"), key_name);
249
250 result = rpccli_spoolss_openprinter_ex(pipe_hnd,
251 mem_ctx,
252 pipe_hnd->srv_name_slash,
253 MAXIMUM_ALLOWED_ACCESS,
254 &hnd);
255 if (!W_ERROR_IS_OK(result)) {
256 d_fprintf(stderr, _("OpenPrinter(%s) failed: %s\n"),
257 pipe_hnd->srv_name_slash, win_errstr(result));
258 return werror_to_ntstatus(result);
259 }
260
261 f1.form_name = key_name;
262 f1.flags = r.flag;
263
264 f1.size.width = r.width;
265 f1.size.height = r.length;
266
267 f1.area.top = r.top;
268 f1.area.right = r.right;
269 f1.area.bottom = r.bottom;
270 f1.area.left = r.left;
271
272 f.info1 = &f1;
273
274 status = rpccli_spoolss_AddForm(pipe_hnd,
275 mem_ctx,
276 &hnd,
277 1,
278 f,
279 &result);
280 if (!NT_STATUS_IS_OK(status)) {
281 d_printf(_("\tAddForm(%s) refused -- %s.\n"),
282 f.info1->form_name, nt_errstr(status));
283 }
284
285 rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd, NULL);
286
287 return status;
288 }
289
290 static NTSTATUS migrate_driver(TALLOC_CTX *mem_ctx,
291 struct rpc_pipe_client *pipe_hnd,
292 const char *key_name,
293 unsigned char *data,
294 size_t length)
295 {
296 enum ndr_err_code ndr_err;
297 struct ntprinting_driver r;
298 struct spoolss_AddDriverInfoCtr d;
299 struct spoolss_AddDriverInfo3 d3;
300 struct spoolss_StringArray a;
301 DATA_BLOB blob;
302 NTSTATUS status;
303 WERROR result;
304
305 blob = data_blob_const(data, length);
306
307 ZERO_STRUCT(r);
308
309 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
310 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_driver);
311 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
312 d_fprintf(stderr, _("driver pull failed: %s\n"),
313 ndr_errstr(ndr_err));
314 return NT_STATUS_NO_MEMORY;
315 }
316
317 d_printf(_("Migrating Printer Driver: %s\n"), key_name);
318
319 ZERO_STRUCT(d3);
320 ZERO_STRUCT(a);
321
322 a.string = r.dependent_files;
323
324 d3.architecture = r.environment;
325 d3.config_file = r.configfile;
326 d3.data_file = r.datafile;
327 d3.default_datatype = r.defaultdatatype;
328 d3.dependent_files = &a;
329 d3.driver_path = r.driverpath;
330 d3.help_file = r.helpfile;
331 d3.monitor_name = r.monitorname;
332 d3.driver_name = r.name;
333 d3.version = r.version;
334
335 d.info.info3 = &d3;
336 d.level = 3;
337
338 status = rpccli_spoolss_AddPrinterDriver(pipe_hnd,
339 mem_ctx,
340 NULL,
341 &d,
342 &result);
343 if (!NT_STATUS_IS_OK(status)) {
344 d_printf(_("\tAddDriver driver: [%s] refused -- %s.\n"),
345 d3.driver_name, nt_errstr(status));
346 }
347
348 return status;
349 }
350
351 static NTSTATUS migrate_printer(TALLOC_CTX *mem_ctx,
352 struct rpc_pipe_client *pipe_hnd,
353 const char *key_name,
354 unsigned char *data,
355 size_t length)
356 {
357 struct policy_handle hnd;
358 enum ndr_err_code ndr_err;
359 struct ntprinting_printer r;
360 struct spoolss_SetPrinterInfo2 info2;
361 struct spoolss_DeviceMode dm;
362 struct spoolss_SetPrinterInfoCtr info_ctr;
363 struct spoolss_DevmodeContainer devmode_ctr;
364 struct sec_desc_buf secdesc_ctr;
365 DATA_BLOB blob;
366 NTSTATUS status;
367 WERROR result;
368 int j;
369
370 if (strequal(key_name, "printers")) {
371 return NT_STATUS_OK;
372 }
373
374 blob = data_blob_const(data, length);
375
376 ZERO_STRUCT(r);
377
378 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
379 (ndr_pull_flags_fn_t) ndr_pull_ntprinting_printer);
380 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
381 d_fprintf(stderr, _("printer pull failed: %s\n"),
382 ndr_errstr(ndr_err));
383 return NT_STATUS_NO_MEMORY;
384 }
385
386 d_printf(_("Migrating Printer: %s\n"), key_name);
387
388 result = rpccli_spoolss_openprinter_ex(pipe_hnd,
389 mem_ctx,
390 key_name,
391 MAXIMUM_ALLOWED_ACCESS,
392 &hnd);
393 if (!W_ERROR_IS_OK(result)) {
394 d_fprintf(stderr, _("OpenPrinter(%s) failed: %s\n"),
395 key_name, win_errstr(result));
396 return werror_to_ntstatus(result);
397 }
398
399 /* Create printer info level 2 */
400 ZERO_STRUCT(info2);
401 ZERO_STRUCT(devmode_ctr);
402 ZERO_STRUCT(secdesc_ctr);
403
404 info2.attributes = r.info.attributes;
405 info2.averageppm = r.info.averageppm;
406 info2.cjobs = r.info.cjobs;
407 info2.comment = r.info.comment;
408 info2.datatype = r.info.datatype;
409 info2.defaultpriority = r.info.default_priority;
410 info2.drivername = r.info.drivername;
411 info2.location = r.info.location;
412 info2.parameters = r.info.parameters;
413 info2.portname = r.info.portname;
414 info2.printername = r.info.printername;
415 info2.printprocessor = r.info.printprocessor;
416 info2.priority = r.info.priority;
417 info2.sepfile = r.info.sepfile;
418 info2.sharename = r.info.sharename;
419 info2.starttime = r.info.starttime;
420 info2.status = r.info.status;
421 info2.untiltime = r.info.untiltime;
422
423 /* Create Device Mode */
424 if (r.devmode != NULL) {
425 ZERO_STRUCT(dm);
426
427 dm.bitsperpel = r.devmode->bitsperpel;
428 dm.collate = r.devmode->collate;
429 dm.color = r.devmode->color;
430 dm.copies = r.devmode->copies;
431 dm.defaultsource = r.devmode->defaultsource;
432 dm.devicename = r.devmode->devicename;
433 dm.displayflags = r.devmode->displayflags;
434 dm.displayfrequency = r.devmode->displayfrequency;
435 dm.dithertype = r.devmode->dithertype;
436 dm.driverversion = r.devmode->driverversion;
437 dm.duplex = r.devmode->duplex;
438 dm.fields = r.devmode->fields;
439 dm.formname = r.devmode->formname;
440 dm.icmintent = r.devmode->icmintent;
441 dm.icmmethod = r.devmode->icmmethod;
442 dm.logpixels = r.devmode->logpixels;
443 dm.mediatype = r.devmode->mediatype;
444 dm.orientation = r.devmode->orientation;
445 dm.panningheight = r.devmode->pelsheight;
446 dm.panningwidth = r.devmode->panningwidth;
447 dm.paperlength = r.devmode->paperlength;
448 dm.papersize = r.devmode->papersize;
449 dm.paperwidth = r.devmode->paperwidth;
450 dm.pelsheight = r.devmode->pelsheight;
451 dm.pelswidth = r.devmode->pelswidth;
452 dm.printquality = r.devmode->printquality;
453 dm.scale = r.devmode->scale;
454 dm.specversion = r.devmode->specversion;
455 dm.ttoption = r.devmode->ttoption;
456 dm.yresolution = r.devmode->yresolution;
457
458 if (r.devmode->nt_dev_private != NULL) {
459 dm.driverextra_data.data = r.devmode->nt_dev_private->data;
460 dm.driverextra_data.length = r.devmode->nt_dev_private->length;
461 dm.__driverextra_length = r.devmode->nt_dev_private->length;
462 }
463
464 devmode_ctr.devmode = &dm;
465
466 info2.devmode_ptr = 1;
467 }
468
469 info_ctr.info.info2 = &info2;
470 info_ctr.level = 2;
471
472 status = rpccli_spoolss_SetPrinter(pipe_hnd,
473 mem_ctx,
474 &hnd,
475 &info_ctr,
476 &devmode_ctr,
477 &secdesc_ctr,
478 0, /* command */
479 &result);
480 if (!NT_STATUS_IS_OK(status)) {
481 d_printf(_("\tSetPrinter(%s) level 2 refused -- %s.\n"),
482 key_name, nt_errstr(status));
483 goto done;
484 }
485
486 /* migrate printerdata */
487 for (j = 0; j < r.count; j++) {
488 char *valuename;
489 char *keyname;
490
491 if (r.printer_data[j].type == REG_NONE) {
492 continue;
493 }
494
495 keyname = CONST_DISCARD(char *, r.printer_data[j].name);
496 valuename = strchr(keyname, '\\');
497 if (valuename == NULL) {
498 continue;
499 } else {
500 valuename[0] = '\0';
501 valuename++;
502 }
503
504 printf(" data: %s\\%s\n", keyname, valuename);
505
506 status = rpccli_spoolss_SetPrinterDataEx(pipe_hnd,
507 mem_ctx,
508 &hnd,
509 keyname,
510 valuename,
511 r.printer_data[j].type,
512 r.printer_data[j].data.data,
513 r.printer_data[j].data.length,
514 &result);
515 if (!NT_STATUS_IS_OK(status)) {
516 d_printf(_("\tSetPrinterDataEx: printer [%s], keyname [%s], valuename [%s] refused -- %s.\n"),
517 key_name, keyname, valuename, nt_errstr(status));
518 break;
519 }
520 }
521
522 done:
523 rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd, NULL);
524
525 return status;
526 }
527
528 static NTSTATUS migrate_secdesc(TALLOC_CTX *mem_ctx,
529 struct rpc_pipe_client *pipe_hnd,
530 const char *key_name,
531 unsigned char *data,
532 size_t length)
533 {
534 struct policy_handle hnd;
535 enum ndr_err_code ndr_err;
536 struct sec_desc_buf secdesc_ctr;
537 struct spoolss_SetPrinterInfo3 info3;
538 struct spoolss_SetPrinterInfoCtr info_ctr;
539 struct spoolss_DevmodeContainer devmode_ctr;
540 DATA_BLOB blob;
541 NTSTATUS status;
542 WERROR result;
543
544 if (strequal(key_name, "printers")) {
545 return NT_STATUS_OK;
546 }
547
548 blob = data_blob_const(data, length);
549
550 ZERO_STRUCT(secdesc_ctr);
551
552 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &secdesc_ctr,
553 (ndr_pull_flags_fn_t)ndr_pull_sec_desc_buf);
554 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
555 d_fprintf(stderr, _("security descriptor pull failed: %s\n"),
556 ndr_errstr(ndr_err));
557 return NT_STATUS_NO_MEMORY;
558 }
559
560 d_printf(_("Migrating Security Descriptor: %s\n"), key_name);
561
562 result = rpccli_spoolss_openprinter_ex(pipe_hnd,
563 mem_ctx,
564 key_name,
565 MAXIMUM_ALLOWED_ACCESS,
566 &hnd);
567 if (!W_ERROR_IS_OK(result)) {
568 d_fprintf(stderr, _("\tOpenPrinter(%s) failed: %s\n"),
569 key_name, win_errstr(result));
570 return werror_to_ntstatus(result);
571 }
572
573 ZERO_STRUCT(devmode_ctr);
574
575 info3.sec_desc_ptr = 1;
576
577 info_ctr.info.info3 = &info3;
578 info_ctr.level = 3;
579
580 status = rpccli_spoolss_SetPrinter(pipe_hnd,
581 mem_ctx,
582 &hnd,
583 &info_ctr,
584 &devmode_ctr,
585 &secdesc_ctr,
586 0, /* command */
587 &result);
588 if (!NT_STATUS_IS_OK(status)) {
589 d_printf(_("\tSetPrinter(%s) level 3 refused -- %s.\n"),
590 key_name, nt_errstr(status));
591 }
592
593 rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd, NULL);
594
595 return status;
596 }
597
598 static NTSTATUS printing_migrate_internal(struct net_context *c,
599 const struct dom_sid *domain_sid,
600 const char *domain_name,
601 struct cli_state *cli,
602 struct rpc_pipe_client *pipe_hnd,
603 TALLOC_CTX *mem_ctx,
604 int argc,
605 const char **argv)
606 {
607 TALLOC_CTX *tmp_ctx;
608 TDB_CONTEXT *tdb;
609 TDB_DATA kbuf, newkey, dbuf;
610 NTSTATUS status;
611
612 tmp_ctx = talloc_new(mem_ctx);
613 if (tmp_ctx == NULL) {
614 return NT_STATUS_NO_MEMORY;
615 }
616
617 tdb = tdb_open_log(argv[0], 0, TDB_DEFAULT, O_RDONLY, 0600);
618 if (tdb == NULL) {
619 d_fprintf(stderr, _("failed to open tdb file: %s\n"), argv[0]);
620 status = NT_STATUS_NO_SUCH_FILE;
621 goto done;
622 }
623
624 for (kbuf = tdb_firstkey(tdb);
625 kbuf.dptr;
626 newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf = newkey)
627 {
628 dbuf = tdb_fetch(tdb, kbuf);
629 if (!dbuf.dptr) {
630 continue;
631 }
632
633 if (strncmp((const char *) kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
634 migrate_form(tmp_ctx,
635 pipe_hnd,
636 (const char *) kbuf.dptr + strlen(FORMS_PREFIX),
637 dbuf.dptr,
638 dbuf.dsize);
639 SAFE_FREE(dbuf.dptr);
640 continue;
641 }
642
643 if (strncmp((const char *) kbuf.dptr, DRIVERS_PREFIX, strlen(DRIVERS_PREFIX)) == 0) {
644 migrate_driver(tmp_ctx,
645 pipe_hnd,
646 (const char *) kbuf.dptr + strlen(DRIVERS_PREFIX),
647 dbuf.dptr,
648 dbuf.dsize);
649 SAFE_FREE(dbuf.dptr);
650 continue;
651 }
652
653 if (strncmp((const char *) kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
654 migrate_printer(tmp_ctx,
655 pipe_hnd,
656 (const char *) kbuf.dptr + strlen(PRINTERS_PREFIX),
657 dbuf.dptr,
658 dbuf.dsize);
659 SAFE_FREE(dbuf.dptr);
660 continue;
661 }
662
663 if (strncmp((const char *) kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
664 migrate_secdesc(tmp_ctx,
665 pipe_hnd,
666 (const char *) kbuf.dptr + strlen(SECDESC_PREFIX),
667 dbuf.dptr,
668 dbuf.dsize);
669 SAFE_FREE(dbuf.dptr);
670 continue;
671 }
672
673 }
674
675 status = NT_STATUS_OK;
676
677 done:
678 talloc_free(tmp_ctx);
679 return status;
680 }
681
682 static int net_printing_migrate(struct net_context *c,
683 int argc,
684 const char **argv)
685 {
686 if (argc < 1 || c->display_usage) {
687 d_printf( "%s\n"
688 "net printing migrate <file.tdb>\n"
689 " %s\n",
690 _("Usage:"),
691 _("Migrate tdb printing files to new storage"));
692 return 0;
693 }
694
695 return run_rpc_command(c,
696 NULL,
697 &ndr_table_spoolss.syntax_id,
698 0,
699 printing_migrate_internal,
700 argc,
701 argv);
702 }
703 /**
704 * 'net printing' entrypoint.
705 * @param argc Standard main() style argc.
706 * @param argv Standard main() style argv. Initial components are already
707 * stripped.
708 **/
709
710 int net_printing(struct net_context *c, int argc, const char **argv)
711 {
712 int ret = -1;
713
714 struct functable func[] = {
715 {
716 "dump",
717 net_printing_dump,
718 NET_TRANSPORT_LOCAL,
719 N_("Dump eventlog"),
720 N_("net printing dump\n"
721 " Dump tdb printing file")
722 },
723
724 {
725 "migrate",
726 net_printing_migrate,
727 NET_TRANSPORT_LOCAL | NET_TRANSPORT_RPC,
728 N_("Migrate printer databases"),
729 N_("net printing migrate\n"
730 " Migrate tdb printing files to new storage")
731 },
732
733 { NULL, NULL, 0, NULL, NULL }
734 };
735
736 ret = net_run_function(c, argc, argv, "net printing", func);
737
738 return ret;
739 }
reg import