source: vendor/3.6.0/source3/utils/net_printing.c

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

Samba Server: update vendor to 3.6.0
File size: 9.3 KB
Line 
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 "system/filesys.h"
24#include "utils/net.h"
25#include "rpc_client/rpc_client.h"
26#include "rpc_client/cli_pipe.h"
27#include "librpc/gen_ndr/ndr_ntprinting.h"
28#include "librpc/gen_ndr/ndr_spoolss.h"
29#include "../libcli/security/security.h"
30#include "../librpc/gen_ndr/ndr_security.h"
31#include "../librpc/gen_ndr/ndr_winreg.h"
32#include "util_tdb.h"
33#include "printing/nt_printing_migrate.h"
34
35#define FORMS_PREFIX "FORMS/"
36#define DRIVERS_PREFIX "DRIVERS/"
37#define PRINTERS_PREFIX "PRINTERS/"
38#define SECDESC_PREFIX "SECDESC/"
39
40static void dump_form(TALLOC_CTX *mem_ctx,
41 const char *key_name,
42 unsigned char *data,
43 size_t length)
44{
45 enum ndr_err_code ndr_err;
46 DATA_BLOB blob;
47 char *s;
48 struct ntprinting_form r;
49
50 printf("found form: %s\n", key_name);
51
52 blob = data_blob_const(data, length);
53
54 ZERO_STRUCT(r);
55
56 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
57 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_form);
58 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
59 d_fprintf(stderr, _("form pull failed: %s\n"),
60 ndr_errstr(ndr_err));
61 return;
62 }
63
64 s = NDR_PRINT_STRUCT_STRING(mem_ctx, ntprinting_form, &r);
65 if (s) {
66 printf("%s\n", s);
67 }
68}
69
70static void dump_driver(TALLOC_CTX *mem_ctx,
71 const char *key_name,
72 unsigned char *data,
73 size_t length)
74{
75 enum ndr_err_code ndr_err;
76 DATA_BLOB blob;
77 char *s;
78 struct ntprinting_driver r;
79
80 printf("found driver: %s\n", key_name);
81
82 blob = data_blob_const(data, length);
83
84 ZERO_STRUCT(r);
85
86 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
87 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_driver);
88 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
89 d_fprintf(stderr, _("driver pull failed: %s\n"),
90 ndr_errstr(ndr_err));
91 return;
92 }
93
94 s = NDR_PRINT_STRUCT_STRING(mem_ctx, ntprinting_driver, &r);
95 if (s) {
96 printf("%s\n", s);
97 }
98}
99
100static void dump_printer(TALLOC_CTX *mem_ctx,
101 const char *key_name,
102 unsigned char *data,
103 size_t length)
104{
105 enum ndr_err_code ndr_err;
106 DATA_BLOB blob;
107 char *s;
108 struct ntprinting_printer r;
109
110 printf("found printer: %s\n", key_name);
111
112 blob = data_blob_const(data, length);
113
114 ZERO_STRUCT(r);
115
116 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
117 (ndr_pull_flags_fn_t)ndr_pull_ntprinting_printer);
118 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
119 d_fprintf(stderr, _("printer pull failed: %s\n"),
120 ndr_errstr(ndr_err));
121 return;
122 }
123
124 s = NDR_PRINT_STRUCT_STRING(mem_ctx, ntprinting_printer, &r);
125 if (s) {
126 printf("%s\n", s);
127 }
128}
129
130static void dump_sd(TALLOC_CTX *mem_ctx,
131 const char *key_name,
132 unsigned char *data,
133 size_t length)
134{
135 enum ndr_err_code ndr_err;
136 DATA_BLOB blob;
137 char *s;
138 struct sec_desc_buf r;
139
140 printf("found security descriptor: %s\n", key_name);
141
142 blob = data_blob_const(data, length);
143
144 ZERO_STRUCT(r);
145
146 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
147 (ndr_pull_flags_fn_t)ndr_pull_sec_desc_buf);
148 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
149 d_fprintf(stderr, _("security descriptor pull failed: %s\n"),
150 ndr_errstr(ndr_err));
151 return;
152 }
153
154 s = NDR_PRINT_STRUCT_STRING(mem_ctx, sec_desc_buf, &r);
155 if (s) {
156 printf("%s\n", s);
157 }
158}
159
160
161static int net_printing_dump(struct net_context *c, int argc,
162 const char **argv)
163{
164 int ret = -1;
165 TALLOC_CTX *ctx = talloc_stackframe();
166 TDB_CONTEXT *tdb;
167 TDB_DATA kbuf, newkey, dbuf;
168
169 if (argc < 1 || c->display_usage) {
170 d_fprintf(stderr, "%s\nnet printing dump <file.tdb>\n",
171 _("Usage:"));
172 goto done;
173 }
174
175 tdb = tdb_open_log(argv[0], 0, TDB_DEFAULT, O_RDONLY, 0600);
176 if (!tdb) {
177 d_fprintf(stderr, _("failed to open tdb file: %s\n"), argv[0]);
178 goto done;
179 }
180
181 for (kbuf = tdb_firstkey(tdb);
182 kbuf.dptr;
183 newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf=newkey)
184 {
185 dbuf = tdb_fetch(tdb, kbuf);
186 if (!dbuf.dptr) {
187 continue;
188 }
189
190 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
191 dump_form(ctx, (const char *)kbuf.dptr+strlen(FORMS_PREFIX), dbuf.dptr, dbuf.dsize);
192 SAFE_FREE(dbuf.dptr);
193 continue;
194 }
195
196 if (strncmp((const char *)kbuf.dptr, DRIVERS_PREFIX, strlen(DRIVERS_PREFIX)) == 0) {
197 dump_driver(ctx, (const char *)kbuf.dptr+strlen(DRIVERS_PREFIX), dbuf.dptr, dbuf.dsize);
198 SAFE_FREE(dbuf.dptr);
199 continue;
200 }
201
202 if (strncmp((const char *)kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
203 dump_printer(ctx, (const char *)kbuf.dptr+strlen(PRINTERS_PREFIX), dbuf.dptr, dbuf.dsize);
204 SAFE_FREE(dbuf.dptr);
205 continue;
206 }
207
208 if (strncmp((const char *)kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
209 dump_sd(ctx, (const char *)kbuf.dptr+strlen(SECDESC_PREFIX), dbuf.dptr, dbuf.dsize);
210 SAFE_FREE(dbuf.dptr);
211 continue;
212 }
213
214 }
215
216 ret = 0;
217
218 done:
219 talloc_free(ctx);
220 return ret;
221}
222
223static NTSTATUS printing_migrate_internal(struct net_context *c,
224 const struct dom_sid *domain_sid,
225 const char *domain_name,
226 struct cli_state *cli,
227 struct rpc_pipe_client *winreg_pipe,
228 TALLOC_CTX *mem_ctx,
229 int argc,
230 const char **argv)
231{
232 TALLOC_CTX *tmp_ctx;
233 TDB_CONTEXT *tdb;
234 TDB_DATA kbuf, newkey, dbuf;
235 NTSTATUS status;
236
237 tmp_ctx = talloc_new(mem_ctx);
238 if (tmp_ctx == NULL) {
239 return NT_STATUS_NO_MEMORY;
240 }
241
242 tdb = tdb_open_log(argv[0], 0, TDB_DEFAULT, O_RDONLY, 0600);
243 if (tdb == NULL) {
244 d_fprintf(stderr, _("failed to open tdb file: %s\n"), argv[0]);
245 status = NT_STATUS_NO_SUCH_FILE;
246 goto done;
247 }
248
249 for (kbuf = tdb_firstkey(tdb);
250 kbuf.dptr;
251 newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf = newkey)
252 {
253 dbuf = tdb_fetch(tdb, kbuf);
254 if (!dbuf.dptr) {
255 continue;
256 }
257
258 if (strncmp((const char *) kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
259 printing_tdb_migrate_form(tmp_ctx,
260 winreg_pipe,
261 (const char *) kbuf.dptr + strlen(FORMS_PREFIX),
262 dbuf.dptr,
263 dbuf.dsize);
264 SAFE_FREE(dbuf.dptr);
265 continue;
266 }
267
268 if (strncmp((const char *) kbuf.dptr, DRIVERS_PREFIX, strlen(DRIVERS_PREFIX)) == 0) {
269 printing_tdb_migrate_driver(tmp_ctx,
270 winreg_pipe,
271 (const char *) kbuf.dptr + strlen(DRIVERS_PREFIX),
272 dbuf.dptr,
273 dbuf.dsize);
274 SAFE_FREE(dbuf.dptr);
275 continue;
276 }
277
278 if (strncmp((const char *) kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
279 printing_tdb_migrate_printer(tmp_ctx,
280 winreg_pipe,
281 (const char *) kbuf.dptr + strlen(PRINTERS_PREFIX),
282 dbuf.dptr,
283 dbuf.dsize);
284 SAFE_FREE(dbuf.dptr);
285 continue;
286 }
287 SAFE_FREE(dbuf.dptr);
288 }
289
290 for (kbuf = tdb_firstkey(tdb);
291 kbuf.dptr;
292 newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf = newkey)
293 {
294 dbuf = tdb_fetch(tdb, kbuf);
295 if (!dbuf.dptr) {
296 continue;
297 }
298
299 if (strncmp((const char *) kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
300 printing_tdb_migrate_secdesc(tmp_ctx,
301 winreg_pipe,
302 (const char *) kbuf.dptr + strlen(SECDESC_PREFIX),
303 dbuf.dptr,
304 dbuf.dsize);
305 SAFE_FREE(dbuf.dptr);
306 continue;
307 }
308 SAFE_FREE(dbuf.dptr);
309
310 }
311
312 status = NT_STATUS_OK;
313
314 done:
315 talloc_free(tmp_ctx);
316 return status;
317}
318
319static int net_printing_migrate(struct net_context *c,
320 int argc,
321 const char **argv)
322{
323 if (argc < 1 || c->display_usage) {
324 d_printf( "%s\n"
325 "net printing migrate <file.tdb>\n"
326 " %s\n",
327 _("Usage:"),
328 _("Migrate tdb printing files to new storage"));
329 return 0;
330 }
331
332 return run_rpc_command(c,
333 NULL,
334 &ndr_table_winreg.syntax_id,
335 0,
336 printing_migrate_internal,
337 argc,
338 argv);
339}
340/**
341 * 'net printing' entrypoint.
342 * @param argc Standard main() style argc.
343 * @param argv Standard main() style argv. Initial components are already
344 * stripped.
345 **/
346
347int net_printing(struct net_context *c, int argc, const char **argv)
348{
349 int ret = -1;
350
351 struct functable func[] = {
352 {
353 "dump",
354 net_printing_dump,
355 NET_TRANSPORT_LOCAL,
356 N_("Dump printer databases"),
357 N_("net printing dump\n"
358 " Dump tdb printing file")
359 },
360
361 {
362 "migrate",
363 net_printing_migrate,
364 NET_TRANSPORT_LOCAL | NET_TRANSPORT_RPC,
365 N_("Migrate printer databases"),
366 N_("net printing migrate\n"
367 " Migrate tdb printing files to new storage")
368 },
369
370 { NULL, NULL, 0, NULL, NULL }
371 };
372
373 ret = net_run_function(c, argc, argv, "net printing", func);
374
375 return ret;
376}
Note: See TracBrowser for help on using the repository browser.