source: vendor/3.6.9/source3/libads/ldap_printer.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: 10.9 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 ads (active directory) printer utility library
4 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20#include "includes.h"
21#include "ads.h"
22#include "rpc_client/rpc_client.h"
23#include "../librpc/gen_ndr/ndr_spoolss_c.h"
24#include "rpc_client/cli_spoolss.h"
25#include "registry/reg_objects.h"
26
27#ifdef HAVE_ADS
28
29/*
30 find a printer given the name and the hostname
31 Note that results "res" may be allocated on return so that the
32 results can be used. It should be freed using ads_msgfree.
33*/
34 ADS_STATUS ads_find_printer_on_server(ADS_STRUCT *ads, LDAPMessage **res,
35 const char *printer,
36 const char *servername)
37{
38 ADS_STATUS status;
39 char *srv_dn, **srv_cn, *s = NULL;
40 const char *attrs[] = {"*", "nTSecurityDescriptor", NULL};
41
42 status = ads_find_machine_acct(ads, res, servername);
43 if (!ADS_ERR_OK(status)) {
44 DEBUG(1, ("ads_find_printer_on_server: cannot find host %s in ads\n",
45 servername));
46 return status;
47 }
48 if (ads_count_replies(ads, *res) != 1) {
49 ads_msgfree(ads, *res);
50 *res = NULL;
51 return ADS_ERROR(LDAP_NO_SUCH_OBJECT);
52 }
53 srv_dn = ldap_get_dn(ads->ldap.ld, *res);
54 if (srv_dn == NULL) {
55 ads_msgfree(ads, *res);
56 *res = NULL;
57 return ADS_ERROR(LDAP_NO_MEMORY);
58 }
59 srv_cn = ldap_explode_dn(srv_dn, 1);
60 if (srv_cn == NULL) {
61 ldap_memfree(srv_dn);
62 ads_msgfree(ads, *res);
63 *res = NULL;
64 return ADS_ERROR(LDAP_INVALID_DN_SYNTAX);
65 }
66 ads_msgfree(ads, *res);
67 *res = NULL;
68
69 if (asprintf(&s, "(cn=%s-%s)", srv_cn[0], printer) == -1) {
70 ldap_memfree(srv_dn);
71 return ADS_ERROR(LDAP_NO_MEMORY);
72 }
73 status = ads_search(ads, res, s, attrs);
74
75 ldap_memfree(srv_dn);
76 ldap_value_free(srv_cn);
77 SAFE_FREE(s);
78 return status;
79}
80
81 ADS_STATUS ads_find_printers(ADS_STRUCT *ads, LDAPMessage **res)
82{
83 const char *ldap_expr;
84 const char *attrs[] = { "objectClass", "printerName", "location", "driverName",
85 "serverName", "description", NULL };
86
87 /* For the moment only display all printers */
88
89 ldap_expr = "(&(!(showInAdvancedViewOnly=TRUE))(uncName=*)"
90 "(objectCategory=printQueue))";
91
92 return ads_search(ads, res, ldap_expr, attrs);
93}
94
95/*
96 modify a printer entry in the directory
97*/
98ADS_STATUS ads_mod_printer_entry(ADS_STRUCT *ads, char *prt_dn,
99 TALLOC_CTX *ctx, const ADS_MODLIST *mods)
100{
101 return ads_gen_mod(ads, prt_dn, *mods);
102}
103
104/*
105 add a printer to the directory
106*/
107ADS_STATUS ads_add_printer_entry(ADS_STRUCT *ads, char *prt_dn,
108 TALLOC_CTX *ctx, ADS_MODLIST *mods)
109{
110 ads_mod_str(ctx, mods, "objectClass", "printQueue");
111 return ads_gen_add(ads, prt_dn, *mods);
112}
113
114/*
115 map a REG_SZ to an ldap mod
116*/
117static bool map_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
118 struct regval_blob *value)
119{
120 char *str_value = NULL;
121 size_t converted_size;
122 ADS_STATUS status;
123
124 if (regval_type(value) != REG_SZ)
125 return false;
126
127 if (regval_size(value) && *((smb_ucs2_t *) regval_data_p(value))) {
128 if (!pull_ucs2_talloc(ctx, &str_value,
129 (const smb_ucs2_t *) regval_data_p(value),
130 &converted_size))
131 {
132 return false;
133 }
134 status = ads_mod_str(ctx, mods, regval_name(value), str_value);
135 return ADS_ERR_OK(status);
136 }
137 return true;
138
139}
140
141/*
142 map a REG_DWORD to an ldap mod
143*/
144static bool map_dword(TALLOC_CTX *ctx, ADS_MODLIST *mods,
145 struct regval_blob *value)
146{
147 char *str_value = NULL;
148 ADS_STATUS status;
149
150 if (regval_type(value) != REG_DWORD)
151 return False;
152 str_value = talloc_asprintf(ctx, "%d", *((uint32 *) regval_data_p(value)));
153 if (!str_value) {
154 return False;
155 }
156 status = ads_mod_str(ctx, mods, regval_name(value), str_value);
157 return ADS_ERR_OK(status);
158}
159
160/*
161 map a boolean REG_BINARY to an ldap mod
162*/
163static bool map_bool(TALLOC_CTX *ctx, ADS_MODLIST *mods,
164 struct regval_blob *value)
165{
166 char *str_value;
167 ADS_STATUS status;
168
169 if ((regval_type(value) != REG_BINARY) || (regval_size(value) != 1))
170 return False;
171 str_value = talloc_asprintf(ctx, "%s",
172 *(regval_data_p(value)) ? "TRUE" : "FALSE");
173 if (!str_value) {
174 return False;
175 }
176 status = ads_mod_str(ctx, mods, regval_name(value), str_value);
177 return ADS_ERR_OK(status);
178}
179
180/*
181 map a REG_MULTI_SZ to an ldap mod
182*/
183static bool map_multi_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
184 struct regval_blob *value)
185{
186 char **str_values = NULL;
187 size_t converted_size;
188 smb_ucs2_t *cur_str = (smb_ucs2_t *) regval_data_p(value);
189 uint32 size = 0, num_vals = 0, i=0;
190 ADS_STATUS status;
191
192 if (regval_type(value) != REG_MULTI_SZ)
193 return False;
194
195 while(cur_str && *cur_str && (size < regval_size(value))) {
196 size += 2 * (strlen_w(cur_str) + 1);
197 cur_str += strlen_w(cur_str) + 1;
198 num_vals++;
199 };
200
201 if (num_vals) {
202 str_values = TALLOC_ARRAY(ctx, char *, num_vals + 1);
203 if (!str_values) {
204 return False;
205 }
206 memset(str_values, '\0',
207 (num_vals + 1) * sizeof(char *));
208
209 cur_str = (smb_ucs2_t *) regval_data_p(value);
210 for (i=0; i < num_vals; i++) {
211 cur_str += pull_ucs2_talloc(ctx, &str_values[i],
212 cur_str, &converted_size) ?
213 converted_size : (size_t)-1;
214 }
215
216 status = ads_mod_strlist(ctx, mods, regval_name(value),
217 (const char **) str_values);
218 return ADS_ERR_OK(status);
219 }
220 return True;
221}
222
223struct valmap_to_ads {
224 const char *valname;
225 bool (*fn)(TALLOC_CTX *, ADS_MODLIST *, struct regval_blob *);
226};
227
228/*
229 map a REG_SZ to an ldap mod
230*/
231static void map_regval_to_ads(TALLOC_CTX *ctx, ADS_MODLIST *mods,
232 struct regval_blob *value)
233{
234 const struct valmap_to_ads map[] = {
235 {SPOOL_REG_ASSETNUMBER, map_sz},
236 {SPOOL_REG_BYTESPERMINUTE, map_dword},
237 {SPOOL_REG_DEFAULTPRIORITY, map_dword},
238 {SPOOL_REG_DESCRIPTION, map_sz},
239 {SPOOL_REG_DRIVERNAME, map_sz},
240 {SPOOL_REG_DRIVERVERSION, map_dword},
241 {SPOOL_REG_FLAGS, map_dword},
242 {SPOOL_REG_LOCATION, map_sz},
243 {SPOOL_REG_OPERATINGSYSTEM, map_sz},
244 {SPOOL_REG_OPERATINGSYSTEMHOTFIX, map_sz},
245 {SPOOL_REG_OPERATINGSYSTEMSERVICEPACK, map_sz},
246 {SPOOL_REG_OPERATINGSYSTEMVERSION, map_sz},
247 {SPOOL_REG_PORTNAME, map_multi_sz},
248 {SPOOL_REG_PRINTATTRIBUTES, map_dword},
249 {SPOOL_REG_PRINTBINNAMES, map_multi_sz},
250 {SPOOL_REG_PRINTCOLLATE, map_bool},
251 {SPOOL_REG_PRINTCOLOR, map_bool},
252 {SPOOL_REG_PRINTDUPLEXSUPPORTED, map_bool},
253 {SPOOL_REG_PRINTENDTIME, map_dword},
254 {SPOOL_REG_PRINTFORMNAME, map_sz},
255 {SPOOL_REG_PRINTKEEPPRINTEDJOBS, map_bool},
256 {SPOOL_REG_PRINTLANGUAGE, map_multi_sz},
257 {SPOOL_REG_PRINTMACADDRESS, map_sz},
258 {SPOOL_REG_PRINTMAXCOPIES, map_sz},
259 {SPOOL_REG_PRINTMAXRESOLUTIONSUPPORTED, map_dword},
260 {SPOOL_REG_PRINTMAXXEXTENT, map_dword},
261 {SPOOL_REG_PRINTMAXYEXTENT, map_dword},
262 {SPOOL_REG_PRINTMEDIAREADY, map_multi_sz},
263 {SPOOL_REG_PRINTMEDIASUPPORTED, map_multi_sz},
264 {SPOOL_REG_PRINTMEMORY, map_dword},
265 {SPOOL_REG_PRINTMINXEXTENT, map_dword},
266 {SPOOL_REG_PRINTMINYEXTENT, map_dword},
267 {SPOOL_REG_PRINTNETWORKADDRESS, map_sz},
268 {SPOOL_REG_PRINTNOTIFY, map_sz},
269 {SPOOL_REG_PRINTNUMBERUP, map_dword},
270 {SPOOL_REG_PRINTORIENTATIONSSUPPORTED, map_multi_sz},
271 {SPOOL_REG_PRINTOWNER, map_sz},
272 {SPOOL_REG_PRINTPAGESPERMINUTE, map_dword},
273 {SPOOL_REG_PRINTRATE, map_dword},
274 {SPOOL_REG_PRINTRATEUNIT, map_sz},
275 {SPOOL_REG_PRINTSEPARATORFILE, map_sz},
276 {SPOOL_REG_PRINTSHARENAME, map_sz},
277 {SPOOL_REG_PRINTSPOOLING, map_sz},
278 {SPOOL_REG_PRINTSTAPLINGSUPPORTED, map_bool},
279 {SPOOL_REG_PRINTSTARTTIME, map_dword},
280 {SPOOL_REG_PRINTSTATUS, map_sz},
281 {SPOOL_REG_PRIORITY, map_dword},
282 {SPOOL_REG_SERVERNAME, map_sz},
283 {SPOOL_REG_SHORTSERVERNAME, map_sz},
284 {SPOOL_REG_UNCNAME, map_sz},
285 {SPOOL_REG_URL, map_sz},
286 {SPOOL_REG_VERSIONNUMBER, map_dword},
287 {NULL, NULL}
288 };
289 int i;
290
291 for (i=0; map[i].valname; i++) {
292 if (StrCaseCmp(map[i].valname, regval_name(value)) == 0) {
293 if (!map[i].fn(ctx, mods, value)) {
294 DEBUG(5, ("Add of value %s to modlist failed\n", regval_name(value)));
295 } else {
296 DEBUG(7, ("Mapped value %s\n", regval_name(value)));
297 }
298
299 }
300 }
301}
302
303
304WERROR get_remote_printer_publishing_data(struct rpc_pipe_client *cli,
305 TALLOC_CTX *mem_ctx,
306 ADS_MODLIST *mods,
307 const char *printer)
308{
309 struct dcerpc_binding_handle *b = cli->binding_handle;
310 WERROR result;
311 char *printername;
312 struct spoolss_PrinterEnumValues *info;
313 uint32_t count;
314 uint32 i;
315 struct policy_handle pol;
316 WERROR werr;
317
318 if ((asprintf(&printername, "%s\\%s", cli->srv_name_slash, printer) == -1)) {
319 DEBUG(3, ("Insufficient memory\n"));
320 return WERR_NOMEM;
321 }
322
323 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
324 printername,
325 SEC_FLAG_MAXIMUM_ALLOWED,
326 &pol);
327 if (!W_ERROR_IS_OK(result)) {
328 DEBUG(3, ("Unable to open printer %s, error is %s.\n",
329 printername, win_errstr(result)));
330 SAFE_FREE(printername);
331 return result;
332 }
333
334 result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &pol,
335 SPOOL_DSDRIVER_KEY,
336 0,
337 &count,
338 &info);
339
340 if (!W_ERROR_IS_OK(result)) {
341 DEBUG(3, ("Unable to do enumdataex on %s, error is %s.\n",
342 printername, win_errstr(result)));
343 } else {
344 /* Have the data we need now, so start building */
345 for (i=0; i < count; i++) {
346 struct regval_blob *v;
347
348 v = regval_compose(mem_ctx, info[i].value_name,
349 info[i].type,
350 info[i].data->data,
351 info[i].data->length);
352 if (v == NULL) {
353 return WERR_NOMEM;
354 }
355
356 map_regval_to_ads(mem_ctx, mods, v);
357 talloc_free(v);
358 }
359 }
360
361 result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &pol,
362 SPOOL_DSSPOOLER_KEY,
363 0,
364 &count,
365 &info);
366 if (!W_ERROR_IS_OK(result)) {
367 DEBUG(3, ("Unable to do enumdataex on %s, error is %s.\n",
368 printername, win_errstr(result)));
369 } else {
370 for (i=0; i < count; i++) {
371 struct regval_blob *v;
372
373 v = regval_compose(mem_ctx, info[i].value_name,
374 info[i].type,
375 info[i].data->data,
376 info[i].data->length);
377 if (v == NULL) {
378 return WERR_NOMEM;
379 }
380
381 map_regval_to_ads(mem_ctx, mods, v);
382 talloc_free(v);
383 }
384 }
385
386 ads_mod_str(mem_ctx, mods, SPOOL_REG_PRINTERNAME, printer);
387
388 dcerpc_spoolss_ClosePrinter(b, mem_ctx, &pol, &werr);
389 SAFE_FREE(printername);
390
391 return result;
392}
393
394#endif
Note: See TracBrowser for help on using the repository browser.