?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dcerpc: we do not need these as public headers
[Samba.git] / source3 / printing / nt_printing_migrate.c
blob59fd04067b5f669977c5bf6e8154ca49d6e4ab49
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 *
5 * Copyright (c) Andreas Schneider 2010.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "printing/nt_printing_migrate.h"
23
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 "librpc/gen_ndr/ndr_security.h"
28 #include "rpc_server/rpc_ncacn_np.h"
29
30 #define FORMS_PREFIX "FORMS/"
31 #define DRIVERS_PREFIX "DRIVERS/"
32 #define PRINTERS_PREFIX "PRINTERS/"
33 #define SECDESC_PREFIX "SECDESC/"
34
35 static NTSTATUS migrate_form(TALLOC_CTX *mem_ctx,
36 struct rpc_pipe_client *pipe_hnd,
37 const char *key_name,
38 unsigned char *data,
39 size_t length)
40 {
41 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
42 struct spoolss_DevmodeContainer devmode_ctr;
43 struct policy_handle hnd;
44 enum ndr_err_code ndr_err;
45 struct ntprinting_form r;
46 union spoolss_AddFormInfo f;
47 struct spoolss_AddFormInfo1 f1;
48 const char *srv_name_slash;
49 DATA_BLOB blob;
50 NTSTATUS status;
51 WERROR result;
52
53
54 blob = data_blob_const(data, length);
55
56 ZERO_STRUCT(r);
57
58 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
59 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_form);
60 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
61 DEBUG(2, ("Form pull failed: %s\n",
62 ndr_errstr(ndr_err)));
63 return NT_STATUS_NO_MEMORY;
64 }
65
66 /* Don't migrate builtin forms */
67 if (r.flag == SPOOLSS_FORM_BUILTIN) {
68 return NT_STATUS_OK;
69 }
70
71 DEBUG(2, ("Migrating Form: %s\n", key_name));
72
73 srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
74 if (srv_name_slash == NULL) {
75 return NT_STATUS_NO_MEMORY;
76 }
77
78 ZERO_STRUCT(devmode_ctr);
79
80 status = dcerpc_spoolss_OpenPrinter(b,
81 mem_ctx,
82 srv_name_slash,
83 NULL,
84 devmode_ctr,
85 SEC_FLAG_MAXIMUM_ALLOWED,
86 &hnd,
87 &result);
88 if (!NT_STATUS_IS_OK(status)) {
89 DEBUG(2, ("dcerpc_spoolss_OpenPrinter(%s) failed: %s\n",
90 srv_name_slash, nt_errstr(status)));
91 return status;
92 }
93 if (!W_ERROR_IS_OK(result)) {
94 DEBUG(2, ("OpenPrinter(%s) failed: %s\n",
95 srv_name_slash, win_errstr(result)));
96 status = werror_to_ntstatus(result);
97 return status;
98 }
99
100 f1.form_name = key_name;
101 f1.flags = r.flag;
102
103 f1.size.width = r.width;
104 f1.size.height = r.length;
105
106 f1.area.top = r.top;
107 f1.area.right = r.right;
108 f1.area.bottom = r.bottom;
109 f1.area.left = r.left;
110
111 f.info1 = &f1;
112
113 status = dcerpc_spoolss_AddForm(b,
114 mem_ctx,
115 &hnd,
116 1,
117 f,
118 &result);
119 if (!NT_STATUS_IS_OK(status)) {
120 DEBUG(2, ("dcerpc_spoolss_AddForm(%s) refused -- %s.\n",
121 f.info1->form_name, nt_errstr(status)));
122 } else if (!W_ERROR_IS_OK(result)) {
123 DEBUG(2, ("AddForm(%s) refused -- %s.\n",
124 f.info1->form_name, win_errstr(result)));
125 status = werror_to_ntstatus(result);
126 }
127
128 dcerpc_spoolss_ClosePrinter(b, mem_ctx, &hnd, &result);
129
130 return status;
131 }
132
133 static NTSTATUS migrate_driver(TALLOC_CTX *mem_ctx,
134 struct rpc_pipe_client *pipe_hnd,
135 const char *key_name,
136 unsigned char *data,
137 size_t length)
138 {
139 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
140 const char *srv_name_slash;
141 enum ndr_err_code ndr_err;
142 struct ntprinting_driver r;
143 struct spoolss_AddDriverInfoCtr d;
144 struct spoolss_AddDriverInfo3 d3;
145 struct spoolss_StringArray a;
146 DATA_BLOB blob;
147 NTSTATUS status;
148 WERROR result;
149
150 blob = data_blob_const(data, length);
151
152 ZERO_STRUCT(r);
153
154 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
155 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_driver);
156 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
157 DEBUG(2, ("Driver pull failed: %s\n",
158 ndr_errstr(ndr_err)));
159 return NT_STATUS_NO_MEMORY;
160 }
161
162 DEBUG(2, ("Migrating Printer Driver: %s\n", key_name));
163
164 srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
165 if (srv_name_slash == NULL) {
166 return NT_STATUS_NO_MEMORY;
167 }
168
169 ZERO_STRUCT(d3);
170 ZERO_STRUCT(a);
171
172 a.string = r.dependent_files;
173
174 d3.architecture = r.environment;
175 d3.config_file = r.configfile;
176 d3.data_file = r.datafile;
177 d3.default_datatype = r.defaultdatatype;
178 d3.dependent_files = &a;
179 d3.driver_path = r.driverpath;
180 d3.help_file = r.helpfile;
181 d3.monitor_name = r.monitorname;
182 d3.driver_name = r.name;
183 d3.version = r.version;
184
185 d.level = 3;
186 d.info.info3 = &d3;
187
188 status = dcerpc_spoolss_AddPrinterDriver(b,
189 mem_ctx,
190 srv_name_slash,
191 &d,
192 &result);
193 if (!NT_STATUS_IS_OK(status)) {
194 DEBUG(2, ("dcerpc_spoolss_AddPrinterDriver(%s) refused -- %s.\n",
195 d3.driver_name, nt_errstr(status)));
196 } else if (!W_ERROR_IS_OK(result)) {
197 DEBUG(2, ("AddPrinterDriver(%s) refused -- %s.\n",
198 d3.driver_name, win_errstr(result)));
199 status = werror_to_ntstatus(result);
200 }
201
202 return status;
203 }
204
205 static NTSTATUS migrate_printer(TALLOC_CTX *mem_ctx,
206 struct rpc_pipe_client *pipe_hnd,
207 const char *key_name,
208 unsigned char *data,
209 size_t length)
210 {
211 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
212 struct policy_handle hnd;
213 enum ndr_err_code ndr_err;
214 struct ntprinting_printer r;
215 struct spoolss_SetPrinterInfo2 info2;
216 struct spoolss_DeviceMode dm;
217 struct spoolss_SetPrinterInfoCtr info_ctr;
218 struct spoolss_DevmodeContainer devmode_ctr;
219 struct sec_desc_buf secdesc_ctr;
220 DATA_BLOB blob;
221 NTSTATUS status;
222 WERROR result;
223 int j;
224
225 if (strequal(key_name, "printers")) {
226 return NT_STATUS_OK;
227 }
228
229 blob = data_blob_const(data, length);
230
231 ZERO_STRUCT(r);
232
233 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
234 (ndr_pull_flags_fn_t) ndr_pull_ntprinting_printer);
235 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
236 DEBUG(2, ("printer pull failed: %s\n",
237 ndr_errstr(ndr_err)));
238 return NT_STATUS_NO_MEMORY;
239 }
240
241 DEBUG(2, ("Migrating Printer: %s\n", key_name));
242
243 ZERO_STRUCT(devmode_ctr);
244
245 status = dcerpc_spoolss_OpenPrinter(b,
246 mem_ctx,
247 key_name,
248 NULL,
249 devmode_ctr,
250 SEC_FLAG_MAXIMUM_ALLOWED,
251 &hnd,
252 &result);
253 if (!NT_STATUS_IS_OK(status)) {
254 DEBUG(2, ("dcerpc_spoolss_OpenPrinter(%s) failed: %s\n",
255 key_name, nt_errstr(status)));
256 return status;
257 }
258 if (!W_ERROR_IS_OK(result)) {
259 DEBUG(2, ("OpenPrinter(%s) failed: %s\n",
260 key_name, win_errstr(result)));
261 status = werror_to_ntstatus(result);
262 return status;
263 }
264
265 /* Create printer info level 2 */
266 ZERO_STRUCT(info2);
267 ZERO_STRUCT(secdesc_ctr);
268
269 info2.attributes = r.info.attributes;
270 info2.averageppm = r.info.averageppm;
271 info2.cjobs = r.info.cjobs;
272 info2.comment = r.info.comment;
273 info2.datatype = r.info.datatype;
274 info2.defaultpriority = r.info.default_priority;
275 info2.drivername = r.info.drivername;
276 info2.location = r.info.location;
277 info2.parameters = r.info.parameters;
278 info2.portname = r.info.portname;
279 info2.printername = r.info.printername;
280 info2.printprocessor = r.info.printprocessor;
281 info2.priority = r.info.priority;
282 info2.sepfile = r.info.sepfile;
283 info2.sharename = r.info.sharename;
284 info2.starttime = r.info.starttime;
285 info2.status = r.info.status;
286 info2.untiltime = r.info.untiltime;
287
288 /* Create Device Mode */
289 if (r.devmode != NULL) {
290 ZERO_STRUCT(dm);
291
292 dm.bitsperpel = r.devmode->bitsperpel;
293 dm.collate = r.devmode->collate;
294 dm.color = r.devmode->color;
295 dm.copies = r.devmode->copies;
296 dm.defaultsource = r.devmode->defaultsource;
297 dm.devicename = r.devmode->devicename;
298 dm.displayflags = r.devmode->displayflags;
299 dm.displayfrequency = r.devmode->displayfrequency;
300 dm.dithertype = r.devmode->dithertype;
301 dm.driverversion = r.devmode->driverversion;
302 dm.duplex = r.devmode->duplex;
303 dm.fields = r.devmode->fields;
304 dm.formname = r.devmode->formname;
305 dm.icmintent = r.devmode->icmintent;
306 dm.icmmethod = r.devmode->icmmethod;
307 dm.logpixels = r.devmode->logpixels;
308 dm.mediatype = r.devmode->mediatype;
309 dm.orientation = r.devmode->orientation;
310 dm.panningheight = r.devmode->pelsheight;
311 dm.panningwidth = r.devmode->panningwidth;
312 dm.paperlength = r.devmode->paperlength;
313 dm.papersize = r.devmode->papersize;
314 dm.paperwidth = r.devmode->paperwidth;
315 dm.pelsheight = r.devmode->pelsheight;
316 dm.pelswidth = r.devmode->pelswidth;
317 dm.printquality = r.devmode->printquality;
318 dm.scale = r.devmode->scale;
319 dm.specversion = r.devmode->specversion;
320 dm.ttoption = r.devmode->ttoption;
321 dm.yresolution = r.devmode->yresolution;
322
323 if (r.devmode->nt_dev_private != NULL) {
324 dm.driverextra_data.data = r.devmode->nt_dev_private->data;
325 dm.driverextra_data.length = r.devmode->nt_dev_private->length;
326 dm.__driverextra_length = r.devmode->nt_dev_private->length;
327 }
328
329 devmode_ctr.devmode = &dm;
330
331 info2.devmode_ptr = 1;
332 }
333
334 info_ctr.info.info2 = &info2;
335 info_ctr.level = 2;
336
337 status = dcerpc_spoolss_SetPrinter(b,
338 mem_ctx,
339 &hnd,
340 &info_ctr,
341 &devmode_ctr,
342 &secdesc_ctr,
343 0, /* command */
344 &result);
345 if (!NT_STATUS_IS_OK(status)) {
346 DEBUG(2, ("dcerpc_spoolss_SetPrinter(%s) level 2 refused -- %s.\n",
347 key_name, nt_errstr(status)));
348 goto done;
349 }
350 if (!W_ERROR_IS_OK(result)) {
351 DEBUG(2, ("SetPrinter(%s) level 2 refused -- %s.\n",
352 key_name, win_errstr(result)));
353 status = werror_to_ntstatus(result);
354 goto done;
355 }
356
357 /* migrate printerdata */
358 for (j = 0; j < r.count; j++) {
359 char *valuename;
360 char *keyname;
361
362 if (r.printer_data[j].type == REG_NONE) {
363 continue;
364 }
365
366 keyname = CONST_DISCARD(char *, r.printer_data[j].name);
367 valuename = strchr(keyname, '\\');
368 if (valuename == NULL) {
369 continue;
370 } else {
371 valuename[0] = '\0';
372 valuename++;
373 }
374
375 status = dcerpc_spoolss_SetPrinterDataEx(b,
376 mem_ctx,
377 &hnd,
378 keyname,
379 valuename,
380 r.printer_data[j].type,
381 r.printer_data[j].data.data,
382 r.printer_data[j].data.length,
383 &result);
384 if (!NT_STATUS_IS_OK(status)) {
385 DEBUG(2, ("dcerpc_spoolss_SetPrinterDataEx: "
386 "printer [%s], keyname [%s], "
387 "valuename [%s] refused -- %s.\n",
388 key_name, keyname, valuename,
389 nt_errstr(status)));
390 break;
391 }
392 if (!W_ERROR_IS_OK(result)) {
393 DEBUG(2, ("SetPrinterDataEx: printer [%s], keyname [%s], "
394 "valuename [%s] refused -- %s.\n",
395 key_name, keyname, valuename,
396 win_errstr(result)));
397 status = werror_to_ntstatus(result);
398 break;
399 }
400 }
401
402 done:
403 dcerpc_spoolss_ClosePrinter(b, mem_ctx, &hnd, &result);
404
405 return status;
406 }
407
408 static NTSTATUS migrate_secdesc(TALLOC_CTX *mem_ctx,
409 struct rpc_pipe_client *pipe_hnd,
410 const char *key_name,
411 unsigned char *data,
412 size_t length)
413 {
414 struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
415 struct policy_handle hnd;
416 enum ndr_err_code ndr_err;
417 struct sec_desc_buf secdesc_ctr;
418 struct spoolss_SetPrinterInfo3 info3;
419 struct spoolss_SetPrinterInfoCtr info_ctr;
420 struct spoolss_DevmodeContainer devmode_ctr;
421 DATA_BLOB blob;
422 NTSTATUS status;
423 WERROR result;
424
425 if (strequal(key_name, "printers")) {
426 return NT_STATUS_OK;
427 }
428
429 blob = data_blob_const(data, length);
430
431 ZERO_STRUCT(secdesc_ctr);
432
433 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &secdesc_ctr,
434 (ndr_pull_flags_fn_t)ndr_pull_sec_desc_buf);
435 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
436 DEBUG(2, ("security descriptor pull failed: %s\n",
437 ndr_errstr(ndr_err)));
438 return NT_STATUS_NO_MEMORY;
439 }
440
441 DEBUG(2, ("Migrating Security Descriptor: %s\n", key_name));
442
443 ZERO_STRUCT(devmode_ctr);
444
445 status = dcerpc_spoolss_OpenPrinter(b,
446 mem_ctx,
447 key_name,
448 NULL,
449 devmode_ctr,
450 SEC_FLAG_MAXIMUM_ALLOWED,
451 &hnd,
452 &result);
453 if (!NT_STATUS_IS_OK(status)) {
454 DEBUG(2, ("dcerpc_spoolss_OpenPrinter(%s) failed: %s\n",
455 key_name, nt_errstr(status)));
456 return status;
457 }
458 if (W_ERROR_EQUAL(WERR_INVALID_PRINTER_NAME, result)) {
459 DEBUG(3, ("Ignoring missing printer %s\n", key_name));
460 return NT_STATUS_OK;
461 }
462 if (!W_ERROR_IS_OK(result)) {
463 DEBUG(2, ("OpenPrinter(%s) failed: %s\n",
464 key_name, win_errstr(result)));
465 status = werror_to_ntstatus(result);
466 return status;
467 }
468
469 ZERO_STRUCT(devmode_ctr);
470
471 info3.sec_desc_ptr = 1;
472
473 info_ctr.info.info3 = &info3;
474 info_ctr.level = 3;
475
476 status = dcerpc_spoolss_SetPrinter(b,
477 mem_ctx,
478 &hnd,
479 &info_ctr,
480 &devmode_ctr,
481 &secdesc_ctr,
482 0, /* command */
483 &result);
484 if (!NT_STATUS_IS_OK(status)) {
485 DEBUG(2, ("dcerpc_spoolss_SetPrinter(%s) level 3 refused -- %s.\n",
486 key_name, nt_errstr(status)));
487 } else if (!W_ERROR_IS_OK(result)) {
488 DEBUG(2, ("SetPrinter(%s) level 3 refused -- %s.\n",
489 key_name, win_errstr(result)));
490 status = werror_to_ntstatus(result);
491 }
492
493 dcerpc_spoolss_ClosePrinter(b, mem_ctx, &hnd, &result);
494
495 return status;
496 }
497
498 static int rename_file_with_suffix(TALLOC_CTX *mem_ctx,
499 const char *path,
500 const char *suffix)
501 {
502 int rc = -1;
503 char *dst_path;
504
505 dst_path = talloc_asprintf(mem_ctx, "%s%s", path, suffix);
506 if (dst_path == NULL) {
507 DEBUG(3, ("error out of memory\n"));
508 return rc;
509 }
510
511 rc = (rename(path, dst_path) != 0);
512
513 if (rc == 0) {
514 DEBUG(5, ("moved '%s' to '%s'\n", path, dst_path));
515 } else if (errno == ENOENT) {
516 DEBUG(3, ("file '%s' does not exist - so not moved\n", path));
517 rc = 0;
518 } else {
519 DEBUG(3, ("error renaming %s to %s: %s\n", path, dst_path,
520 strerror(errno)));
521 }
522
523 TALLOC_FREE(dst_path);
524 return rc;
525 }
526
527 static NTSTATUS migrate_internal(TALLOC_CTX *mem_ctx,
528 const char *tdb_path,
529 struct rpc_pipe_client *pipe_hnd)
530 {
531 const char *backup_suffix = ".bak";
532 TDB_DATA kbuf, newkey, dbuf;
533 TDB_CONTEXT *tdb;
534 NTSTATUS status;
535 int rc;
536
537 tdb = tdb_open_log(tdb_path, 0, TDB_DEFAULT, O_RDONLY, 0600);
538 if (tdb == NULL && errno == ENOENT) {
539 /* if we have no printers database then migration is
540 considered successful */
541 DEBUG(4, ("No printers database to migrate in %s\n", tdb_path));
542 return NT_STATUS_OK;
543 }
544 if (tdb == NULL) {
545 DEBUG(2, ("Failed to open tdb file: %s\n", tdb_path));
546 return NT_STATUS_NO_SUCH_FILE;
547 }
548
549 for (kbuf = tdb_firstkey(tdb);
550 kbuf.dptr;
551 newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf = newkey)
552 {
553 dbuf = tdb_fetch(tdb, kbuf);
554 if (!dbuf.dptr) {
555 continue;
556 }
557
558 if (strncmp((const char *) kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
559 status = migrate_form(mem_ctx,
560 pipe_hnd,
561 (const char *) kbuf.dptr + strlen(FORMS_PREFIX),
562 dbuf.dptr,
563 dbuf.dsize);
564 SAFE_FREE(dbuf.dptr);
565 if (!NT_STATUS_IS_OK(status)) {
566 tdb_close(tdb);
567 return status;
568 }
569 continue;
570 }
571
572 if (strncmp((const char *) kbuf.dptr, DRIVERS_PREFIX, strlen(DRIVERS_PREFIX)) == 0) {
573 status = migrate_driver(mem_ctx,
574 pipe_hnd,
575 (const char *) kbuf.dptr + strlen(DRIVERS_PREFIX),
576 dbuf.dptr,
577 dbuf.dsize);
578 SAFE_FREE(dbuf.dptr);
579 if (!NT_STATUS_IS_OK(status)) {
580 tdb_close(tdb);
581 return status;
582 }
583 continue;
584 }
585
586 if (strncmp((const char *) kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
587 status = migrate_printer(mem_ctx,
588 pipe_hnd,
589 (const char *) kbuf.dptr + strlen(PRINTERS_PREFIX),
590 dbuf.dptr,
591 dbuf.dsize);
592 SAFE_FREE(dbuf.dptr);
593 if (!NT_STATUS_IS_OK(status)) {
594 tdb_close(tdb);
595 return status;
596 }
597 continue;
598 }
599
600 if (strncmp((const char *) kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
601 status = migrate_secdesc(mem_ctx,
602 pipe_hnd,
603 (const char *) kbuf.dptr + strlen(SECDESC_PREFIX),
604 dbuf.dptr,
605 dbuf.dsize);
606 SAFE_FREE(dbuf.dptr);
607 if (!NT_STATUS_IS_OK(status)) {
608 tdb_close(tdb);
609 return status;
610 }
611 continue;
612 }
613 }
614
615 tdb_close(tdb);
616
617 rc = rename_file_with_suffix(mem_ctx, tdb_path, backup_suffix);
618 if (rc != 0) {
619 DEBUG(0, ("Error moving tdb to '%s%s'\n",
620 tdb_path, backup_suffix));
621 }
622
623 return NT_STATUS_OK;
624 }
625
626 bool nt_printing_tdb_migrate(struct messaging_context *msg_ctx)
627 {
628 const char *drivers_path = state_path("ntdrivers.tdb");
629 const char *printers_path = state_path("ntprinters.tdb");
630 const char *forms_path = state_path("ntforms.tdb");
631 bool drivers_exists = file_exist(drivers_path);
632 bool printers_exists = file_exist(printers_path);
633 bool forms_exists = file_exist(forms_path);
634 struct auth_serversupplied_info *session_info;
635 struct rpc_pipe_client *spoolss_pipe = NULL;
636 TALLOC_CTX *tmp_ctx = talloc_stackframe();
637 NTSTATUS status;
638
639 if (!drivers_exists && !printers_exists && !forms_exists) {
640 return true;
641 }
642
643 status = make_session_info_system(tmp_ctx, &session_info);
644 if (!NT_STATUS_IS_OK(status)) {
645 DEBUG(0, ("Couldn't create session_info: %s\n",
646 nt_errstr(status)));
647 talloc_free(tmp_ctx);
648 return false;
649 }
650
651 status = rpc_pipe_open_internal(tmp_ctx,
652 &ndr_table_spoolss.syntax_id,
653 session_info,
654 NULL,
655 msg_ctx,
656 &spoolss_pipe);
657 if (!NT_STATUS_IS_OK(status)) {
658 DEBUG(0, ("Couldn't open internal spoolss pipe: %s\n",
659 nt_errstr(status)));
660 talloc_free(tmp_ctx);
661 return false;
662 }
663
664 if (drivers_exists) {
665 status = migrate_internal(tmp_ctx, drivers_path, spoolss_pipe);
666 if (!NT_STATUS_IS_OK(status)) {
667 DEBUG(0, ("Couldn't migrate drivers tdb file: %s\n",
668 nt_errstr(status)));
669 talloc_free(tmp_ctx);
670 return false;
671 }
672 }
673
674 if (printers_exists) {
675 status = migrate_internal(tmp_ctx, printers_path, spoolss_pipe);
676 if (!NT_STATUS_IS_OK(status)) {
677 DEBUG(0, ("Couldn't migrate printers tdb file: %s\n",
678 nt_errstr(status)));
679 talloc_free(tmp_ctx);
680 return false;
681 }
682 }
683
684 if (forms_exists) {
685 status = migrate_internal(tmp_ctx, forms_path, spoolss_pipe);
686 if (!NT_STATUS_IS_OK(status)) {
687 DEBUG(0, ("Couldn't migrate forms tdb file: %s\n",
688 nt_errstr(status)));
689 talloc_free(tmp_ctx);
690 return false;
691 }
692 }
693
694 talloc_free(tmp_ctx);
695 return true;
696 }
Samba GIT mirror