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