source: trunk-3.0/source/libads/ldap_printer.c@ 101

Last change on this file since 101 was 1, checked in by Paul Smedley, 18 years ago

Initial code import
File size: 10.1 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 2 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, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
21#include "includes.h"
22
23#ifdef HAVE_ADS
24
25/*
26 find a printer given the name and the hostname
27 Note that results "res" may be allocated on return so that the
28 results can be used. It should be freed using ads_msgfree.
29*/
30 ADS_STATUS ads_find_printer_on_server(ADS_STRUCT *ads, LDAPMessage **res,
31 const char *printer,
32 const char *servername)
33{
34 ADS_STATUS status;
35 char *srv_dn, **srv_cn, *s;
36 const char *attrs[] = {"*", "nTSecurityDescriptor", NULL};
37
38 status = ads_find_machine_acct(ads, res, servername);
39 if (!ADS_ERR_OK(status)) {
40 DEBUG(1, ("ads_find_printer_on_server: cannot find host %s in ads\n",
41 servername));
42 return status;
43 }
44 if (ads_count_replies(ads, *res) != 1) {
45 return ADS_ERROR(LDAP_NO_SUCH_OBJECT);
46 }
47 srv_dn = ldap_get_dn(ads->ld, *res);
48 if (srv_dn == NULL) {
49 return ADS_ERROR(LDAP_NO_MEMORY);
50 }
51 srv_cn = ldap_explode_dn(srv_dn, 1);
52 if (srv_cn == NULL) {
53 ldap_memfree(srv_dn);
54 return ADS_ERROR(LDAP_INVALID_DN_SYNTAX);
55 }
56 ads_msgfree(ads, *res);
57
58 asprintf(&s, "(cn=%s-%s)", srv_cn[0], printer);
59 status = ads_search(ads, res, s, attrs);
60
61 ldap_memfree(srv_dn);
62 ldap_value_free(srv_cn);
63 free(s);
64 return status;
65}
66
67 ADS_STATUS ads_find_printers(ADS_STRUCT *ads, LDAPMessage **res)
68{
69 const char *ldap_expr;
70 const char *attrs[] = { "objectClass", "printerName", "location", "driverName",
71 "serverName", "description", NULL };
72
73 /* For the moment only display all printers */
74
75 ldap_expr = "(&(!(showInAdvancedViewOnly=TRUE))(uncName=*)"
76 "(objectCategory=printQueue))";
77
78 return ads_search(ads, res, ldap_expr, attrs);
79}
80
81/*
82 modify a printer entry in the directory
83*/
84ADS_STATUS ads_mod_printer_entry(ADS_STRUCT *ads, char *prt_dn,
85 TALLOC_CTX *ctx, const ADS_MODLIST *mods)
86{
87 return ads_gen_mod(ads, prt_dn, *mods);
88}
89
90/*
91 add a printer to the directory
92*/
93ADS_STATUS ads_add_printer_entry(ADS_STRUCT *ads, char *prt_dn,
94 TALLOC_CTX *ctx, ADS_MODLIST *mods)
95{
96 ads_mod_str(ctx, mods, "objectClass", "printQueue");
97 return ads_gen_add(ads, prt_dn, *mods);
98}
99
100/*
101 map a REG_SZ to an ldap mod
102*/
103static BOOL map_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
104 const REGISTRY_VALUE *value)
105{
106 char *str_value = NULL;
107 ADS_STATUS status;
108
109 if (value->type != REG_SZ)
110 return False;
111
112 if (value->size && *((smb_ucs2_t *) value->data_p)) {
113 pull_ucs2_talloc(ctx, &str_value, (const smb_ucs2_t *) value->data_p);
114 status = ads_mod_str(ctx, mods, value->valuename, str_value);
115 return ADS_ERR_OK(status);
116 }
117 return True;
118
119}
120
121/*
122 map a REG_DWORD to an ldap mod
123*/
124static BOOL map_dword(TALLOC_CTX *ctx, ADS_MODLIST *mods,
125 const REGISTRY_VALUE *value)
126{
127 char *str_value = NULL;
128 ADS_STATUS status;
129
130 if (value->type != REG_DWORD)
131 return False;
132 str_value = talloc_asprintf(ctx, "%d", *((uint32 *) value->data_p));
133 if (!str_value) {
134 return False;
135 }
136 status = ads_mod_str(ctx, mods, value->valuename, str_value);
137 return ADS_ERR_OK(status);
138}
139
140/*
141 map a boolean REG_BINARY to an ldap mod
142*/
143static BOOL map_bool(TALLOC_CTX *ctx, ADS_MODLIST *mods,
144 const REGISTRY_VALUE *value)
145{
146 char *str_value;
147 ADS_STATUS status;
148
149 if ((value->type != REG_BINARY) || (value->size != 1))
150 return False;
151 str_value = talloc_asprintf(ctx, "%s",
152 *(value->data_p) ? "TRUE" : "FALSE");
153 if (!str_value) {
154 return False;
155 }
156 status = ads_mod_str(ctx, mods, value->valuename, str_value);
157 return ADS_ERR_OK(status);
158}
159
160/*
161 map a REG_MULTI_SZ to an ldap mod
162*/
163static BOOL map_multi_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
164 const REGISTRY_VALUE *value)
165{
166 char **str_values = NULL;
167 smb_ucs2_t *cur_str = (smb_ucs2_t *) value->data_p;
168 uint32 size = 0, num_vals = 0, i=0;
169 ADS_STATUS status;
170
171 if (value->type != REG_MULTI_SZ)
172 return False;
173
174 while(cur_str && *cur_str && (size < value->size)) {
175 size += 2 * (strlen_w(cur_str) + 1);
176 cur_str += strlen_w(cur_str) + 1;
177 num_vals++;
178 };
179
180 if (num_vals) {
181 str_values = TALLOC_ARRAY(ctx, char *, num_vals + 1);
182 if (!str_values) {
183 return False;
184 }
185 memset(str_values, '\0',
186 (num_vals + 1) * sizeof(char *));
187
188 cur_str = (smb_ucs2_t *) value->data_p;
189 for (i=0; i < num_vals; i++)
190 cur_str += pull_ucs2_talloc(ctx, &str_values[i],
191 cur_str);
192
193 status = ads_mod_strlist(ctx, mods, value->valuename,
194 (const char **) str_values);
195 return ADS_ERR_OK(status);
196 }
197 return True;
198}
199
200struct valmap_to_ads {
201 const char *valname;
202 BOOL (*fn)(TALLOC_CTX *, ADS_MODLIST *, const REGISTRY_VALUE *);
203};
204
205/*
206 map a REG_SZ to an ldap mod
207*/
208static void map_regval_to_ads(TALLOC_CTX *ctx, ADS_MODLIST *mods,
209 REGISTRY_VALUE *value)
210{
211 const struct valmap_to_ads map[] = {
212 {SPOOL_REG_ASSETNUMBER, map_sz},
213 {SPOOL_REG_BYTESPERMINUTE, map_dword},
214 {SPOOL_REG_DEFAULTPRIORITY, map_dword},
215 {SPOOL_REG_DESCRIPTION, map_sz},
216 {SPOOL_REG_DRIVERNAME, map_sz},
217 {SPOOL_REG_DRIVERVERSION, map_dword},
218 {SPOOL_REG_FLAGS, map_dword},
219 {SPOOL_REG_LOCATION, map_sz},
220 {SPOOL_REG_OPERATINGSYSTEM, map_sz},
221 {SPOOL_REG_OPERATINGSYSTEMHOTFIX, map_sz},
222 {SPOOL_REG_OPERATINGSYSTEMSERVICEPACK, map_sz},
223 {SPOOL_REG_OPERATINGSYSTEMVERSION, map_sz},
224 {SPOOL_REG_PORTNAME, map_multi_sz},
225 {SPOOL_REG_PRINTATTRIBUTES, map_dword},
226 {SPOOL_REG_PRINTBINNAMES, map_multi_sz},
227 {SPOOL_REG_PRINTCOLLATE, map_bool},
228 {SPOOL_REG_PRINTCOLOR, map_bool},
229 {SPOOL_REG_PRINTDUPLEXSUPPORTED, map_bool},
230 {SPOOL_REG_PRINTENDTIME, map_dword},
231 {SPOOL_REG_PRINTFORMNAME, map_sz},
232 {SPOOL_REG_PRINTKEEPPRINTEDJOBS, map_bool},
233 {SPOOL_REG_PRINTLANGUAGE, map_multi_sz},
234 {SPOOL_REG_PRINTMACADDRESS, map_sz},
235 {SPOOL_REG_PRINTMAXCOPIES, map_sz},
236 {SPOOL_REG_PRINTMAXRESOLUTIONSUPPORTED, map_dword},
237 {SPOOL_REG_PRINTMAXXEXTENT, map_dword},
238 {SPOOL_REG_PRINTMAXYEXTENT, map_dword},
239 {SPOOL_REG_PRINTMEDIAREADY, map_multi_sz},
240 {SPOOL_REG_PRINTMEDIASUPPORTED, map_multi_sz},
241 {SPOOL_REG_PRINTMEMORY, map_dword},
242 {SPOOL_REG_PRINTMINXEXTENT, map_dword},
243 {SPOOL_REG_PRINTMINYEXTENT, map_dword},
244 {SPOOL_REG_PRINTNETWORKADDRESS, map_sz},
245 {SPOOL_REG_PRINTNOTIFY, map_sz},
246 {SPOOL_REG_PRINTNUMBERUP, map_dword},
247 {SPOOL_REG_PRINTORIENTATIONSSUPPORTED, map_multi_sz},
248 {SPOOL_REG_PRINTOWNER, map_sz},
249 {SPOOL_REG_PRINTPAGESPERMINUTE, map_dword},
250 {SPOOL_REG_PRINTRATE, map_dword},
251 {SPOOL_REG_PRINTRATEUNIT, map_sz},
252 {SPOOL_REG_PRINTSEPARATORFILE, map_sz},
253 {SPOOL_REG_PRINTSHARENAME, map_sz},
254 {SPOOL_REG_PRINTSPOOLING, map_sz},
255 {SPOOL_REG_PRINTSTAPLINGSUPPORTED, map_bool},
256 {SPOOL_REG_PRINTSTARTTIME, map_dword},
257 {SPOOL_REG_PRINTSTATUS, map_sz},
258 {SPOOL_REG_PRIORITY, map_dword},
259 {SPOOL_REG_SERVERNAME, map_sz},
260 {SPOOL_REG_SHORTSERVERNAME, map_sz},
261 {SPOOL_REG_UNCNAME, map_sz},
262 {SPOOL_REG_URL, map_sz},
263 {SPOOL_REG_VERSIONNUMBER, map_dword},
264 {NULL, NULL}
265 };
266 int i;
267
268 for (i=0; map[i].valname; i++) {
269 if (StrCaseCmp(map[i].valname, value->valuename) == 0) {
270 if (!map[i].fn(ctx, mods, value)) {
271 DEBUG(5, ("Add of value %s to modlist failed\n", value->valuename));
272 } else {
273 DEBUG(7, ("Mapped value %s\n", value->valuename));
274 }
275
276 }
277 }
278}
279
280
281WERROR get_remote_printer_publishing_data(struct rpc_pipe_client *cli,
282 TALLOC_CTX *mem_ctx,
283 ADS_MODLIST *mods,
284 const char *printer)
285{
286 WERROR result;
287 char *printername, *servername;
288 REGVAL_CTR *dsdriver_ctr, *dsspooler_ctr;
289 uint32 i;
290 POLICY_HND pol;
291
292 asprintf(&servername, "\\\\%s", cli->cli->desthost);
293 asprintf(&printername, "%s\\%s", servername, printer);
294 if (!servername || !printername) {
295 DEBUG(3, ("Insufficient memory\n"));
296 return WERR_NOMEM;
297 }
298
299 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
300 "", MAXIMUM_ALLOWED_ACCESS,
301 servername, cli->cli->user_name, &pol);
302 if (!W_ERROR_IS_OK(result)) {
303 DEBUG(3, ("Unable to open printer %s, error is %s.\n",
304 printername, dos_errstr(result)));
305 return result;
306 }
307
308 if ( !(dsdriver_ctr = TALLOC_ZERO_P( mem_ctx, REGVAL_CTR )) )
309 return WERR_NOMEM;
310
311 result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &pol, SPOOL_DSDRIVER_KEY, dsdriver_ctr);
312
313 if (!W_ERROR_IS_OK(result)) {
314 DEBUG(3, ("Unable to do enumdataex on %s, error is %s.\n",
315 printername, dos_errstr(result)));
316 } else {
317 uint32 num_values = regval_ctr_numvals( dsdriver_ctr );
318
319 /* Have the data we need now, so start building */
320 for (i=0; i < num_values; i++) {
321 map_regval_to_ads(mem_ctx, mods, dsdriver_ctr->values[i]);
322 }
323 }
324
325 if ( !(dsspooler_ctr = TALLOC_ZERO_P( mem_ctx, REGVAL_CTR )) )
326 return WERR_NOMEM;
327
328 result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &pol, SPOOL_DSSPOOLER_KEY, dsspooler_ctr);
329
330 if (!W_ERROR_IS_OK(result)) {
331 DEBUG(3, ("Unable to do enumdataex on %s, error is %s.\n",
332 printername, dos_errstr(result)));
333 } else {
334 uint32 num_values = regval_ctr_numvals( dsspooler_ctr );
335
336 for (i=0; i<num_values; i++) {
337 map_regval_to_ads(mem_ctx, mods, dsspooler_ctr->values[i]);
338 }
339 }
340
341 ads_mod_str(mem_ctx, mods, SPOOL_REG_PRINTERNAME, printer);
342
343 TALLOC_FREE( dsdriver_ctr );
344 TALLOC_FREE( dsspooler_ctr );
345
346 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
347
348 return result;
349}
350
351BOOL get_local_printer_publishing_data(TALLOC_CTX *mem_ctx,
352 ADS_MODLIST *mods,
353 NT_PRINTER_DATA *data)
354{
355 uint32 key,val;
356
357 for (key=0; key < data->num_keys; key++) {
358 REGVAL_CTR *ctr = data->keys[key].values;
359 for (val=0; val < ctr->num_values; val++)
360 map_regval_to_ads(mem_ctx, mods, ctr->values[val]);
361 }
362 return True;
363}
364
365#endif
Note: See TracBrowser for help on using the repository browser.