xref: /titanic_44/usr/src/lib/print/libpapi-dynamic/common/printer.c (revision 56b2bdd1f04d465cfe4a95b88ae5cba5884154e4)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  *
26  */
27 
28 /* $Id: printer.c 151 2006-04-25 16:55:34Z njacobs $ */
29 
30 #pragma ident	"%Z%%M%	%I%	%E% SMI"
31 
32 /*LINTLIBRARY*/
33 
34 #include <stdlib.h>
35 #include <papi_impl.h>
36 
37 void
38 papiPrinterFree(papi_printer_t printer)
39 {
40 	printer_t *tmp = printer;
41 
42 	if (tmp != NULL) {
43 		void (*f)();
44 
45 		f = (void (*)())psm_sym(tmp->svc, "papiPrinterFree");
46 		if (f != NULL)
47 			f(tmp->printer);
48 		if (tmp->attributes != NULL)
49 			papiAttributeListFree(tmp->attributes);
50 		if (tmp->svc_is_internal != 0)
51 			papiServiceDestroy(tmp->svc);
52 		free(tmp);
53 	}
54 }
55 
56 void
57 papiPrinterListFree(papi_printer_t *printers)
58 {
59 	if (printers != NULL) {
60 		int i;
61 
62 		for (i = 0; printers[i] != NULL; i++)
63 			papiPrinterFree(printers[i]);
64 		free(printers);
65 	}
66 }
67 
68 /* Enumerate a list of printers from the loaded print service. */
69 static papi_status_t
70 printers_from_service(service_t *svc, char **requested_attrs,
71 		papi_filter_t *filter, papi_printer_t **printers)
72 {
73 	papi_status_t result = PAPI_INTERNAL_ERROR;
74 	papi_printer_t *svc_printers = NULL;
75 	papi_status_t (*f)();
76 
77 	if ((svc == NULL) || (printers == NULL))
78 		return (PAPI_BAD_ARGUMENT);
79 
80 	/* connect to the service if we are not connected */
81 	if ((result = service_connect(svc, svc->name)) != PAPI_OK)
82 		return (result);
83 
84 	f = (papi_status_t (*)())psm_sym(svc, "papiPrintersList");
85 	if (f != NULL)
86 		result = f(svc->svc_handle, requested_attrs, filter,
87 				&svc_printers);
88 
89 	/*
90 	 * copy the resulting printer object pointers into our own
91 	 * representation of a printer object because we need the
92 	 * service context to operate against the individual printer
93 	 * objects.  We free the list now because we no longer need
94 	 * it and would have no way of freeing it later.
95 	 */
96 	if ((result == PAPI_OK) && (svc_printers != NULL)) {
97 		int i;
98 
99 		*printers = NULL;
100 		for (i = 0; svc_printers[i] != NULL; i++) {
101 			printer_t *p = NULL;
102 
103 			if ((p = calloc(1, sizeof (*p))) == NULL)
104 				return (PAPI_TEMPORARY_ERROR);
105 
106 			p->svc = svc;
107 			p->printer = svc_printers[i];
108 			list_append(printers, p);
109 		}
110 		free(svc_printers);
111 	}
112 
113 	return (result);
114 }
115 
116 /* Get printer attributes from it's print service */
117 static papi_status_t
118 printer_from_service(service_t *svc, printer_t *p, char **requested_attrs)
119 {
120 	papi_status_t result;
121 	papi_service_t p_svc = NULL;
122 	papi_printer_t printer = NULL;
123 	char *psm = NULL;
124 	char *uri = NULL;
125 
126 	/* get the psm and uri from the attributes */
127 	papiAttributeListGetString(p->attributes, NULL,
128 			"print-service-module", &psm);
129 	papiAttributeListGetString(p->attributes, NULL, "printer-name", &uri);
130 	papiAttributeListGetString(p->attributes, NULL, "printer-uri-supported",
131 			&uri);
132 
133 	/* contact the service for the printer */
134 	result = papiServiceCreate((papi_service_t *)&p_svc, psm, svc->user,
135 				svc->password, svc->authCB, svc->encryption,
136 				svc->app_data);
137 	if (result != PAPI_OK)
138 		return (result);
139 
140 	/* get the printer from the service */
141 	result = papiPrinterQuery(p_svc, uri, requested_attrs, NULL, &printer);
142 	if (result == PAPI_OK) {
143 		papi_attribute_t **attributes;
144 
145 		attributes = papiPrinterGetAttributeList(printer);
146 		copy_attributes(&p->attributes, attributes);
147 	}
148 	papiPrinterFree(printer);
149 	papiServiceDestroy(p_svc);
150 
151 	return (result);
152 }
153 
154 /* are the requested attributes contained in the list */
155 static int
156 contained(char **requested, papi_attribute_t **list)
157 {
158 	int i;
159 
160 	if (requested == NULL)	/* we want every possible attribute */
161 		return (0);
162 
163 	for (i = 0; requested[i] != NULL; i++)
164 		if (papiAttributeListFind(list, requested[i]) == NULL)
165 			return (0);
166 
167 	return (1);
168 }
169 
170 /* Enumerate a list of printers from the Name Service */
171 static papi_status_t
172 printers_from_name_service(service_t *svc, char **requested_attrs,
173 		papi_filter_t *filter, papi_printer_t **printers)
174 {
175 	papi_status_t result = PAPI_INTERNAL_ERROR;
176 	papi_attribute_t **attrs;
177 
178 	if ((svc == NULL) || (printers == NULL))
179 		return (PAPI_BAD_ARGUMENT);
180 
181 	/* retrieve printers from the nameservice */
182 	setprinterentry(0, NULL);
183 	while ((attrs = getprinterentry(NULL)) != NULL) {
184 		printer_t *p = NULL;
185 
186 		if ((p = calloc(1, sizeof (*p))) == NULL)
187 			return (PAPI_TEMPORARY_ERROR);
188 
189 		p->attributes = attrs;
190 		list_append(printers, p);
191 	}
192 
193 	/* if we have printers, check if our request has been satisfied */
194 	if ((printers != NULL) && (*printers != NULL)) {
195 		int i;
196 
197 		/* walk through the list */
198 		for (i = 0; (*printers)[i] != NULL; i++) {
199 			printer_t *p = (*printers)[i];
200 
201 			/* see if the name service satisfied the request */
202 			if (contained(requested_attrs, p->attributes) == 0)
203 				printer_from_service(svc, p, requested_attrs);
204 		}
205 	}
206 
207 	return (PAPI_OK);
208 }
209 
210 papi_status_t
211 papiPrintersList(papi_service_t handle, char **requested_attrs,
212 		papi_filter_t *filter, papi_printer_t **printers)
213 {
214 	papi_status_t result = PAPI_INTERNAL_ERROR;
215 	service_t *svc = handle;
216 	papi_printer_t *svc_printers = NULL;
217 	papi_status_t (*f)();
218 
219 	if ((svc == NULL) || (printers == NULL))
220 		return (PAPI_BAD_ARGUMENT);
221 
222 	if (svc->so_handle != NULL)	/* connected, use the print svc */
223 		result = printers_from_service(svc, requested_attrs,
224 					filter, printers);
225 	else				/* not connected, use the name svc */
226 		result = printers_from_name_service(svc, requested_attrs,
227 					filter, printers);
228 
229 	return (result);
230 }
231 
232 papi_status_t
233 papiPrinterQuery(papi_service_t handle, char *name, char **requested_attrs,
234 		papi_attribute_t **job_attributes, papi_printer_t *printer)
235 {
236 	papi_status_t result = PAPI_INTERNAL_ERROR;
237 	service_t *svc = handle;
238 	printer_t *p = NULL;
239 	papi_status_t (*f)();
240 
241 	if ((svc == NULL) || (name == NULL) || (printer == NULL))
242 		return (PAPI_BAD_ARGUMENT);
243 
244 	if ((result = service_connect(svc, name)) != PAPI_OK)
245 		return (result);
246 
247 	if ((*printer = p = calloc(1, sizeof (*p))) == NULL)
248 		return (PAPI_TEMPORARY_ERROR);
249 
250 	if ((svc->name != NULL) && (svc->svc_handle != NULL) &&
251 	    (svc->uri != NULL)) {
252 		p->svc = svc;
253 		f = (papi_status_t (*)())psm_sym(p->svc, "papiPrinterQuery");
254 		if (f != NULL)
255 			result = f(svc->svc_handle, svc->name, requested_attrs,
256 					job_attributes, &p->printer);
257 	} else {
258 		setprinterentry(0, NULL);
259 		p->attributes = getprinterbyname(name, NULL);
260 		if (p->attributes == NULL)
261 			result = PAPI_NOT_FOUND;
262 		else
263 			result = PAPI_OK;
264 	}
265 
266 	return (result);
267 }
268 
269 static papi_status_t
270 _papi_printer_disable_or_pause(papi_service_t handle, char *name, char *message,
271 		char *function)
272 {
273 	papi_status_t result = PAPI_INTERNAL_ERROR;
274 	service_t *svc = handle;
275 	papi_status_t (*f)();
276 
277 	if ((svc == NULL) || (name == NULL))
278 		return (PAPI_BAD_ARGUMENT);
279 
280 	if ((result = service_connect(svc, name)) != PAPI_OK)
281 		return (result);
282 
283 	f = (papi_status_t (*)())psm_sym(svc, function);
284 	if (f != NULL)
285 		result = f(svc->svc_handle, svc->name, message);
286 
287 	return (result);
288 }
289 
290 static papi_status_t
291 _papi_printer_enable_or_resume(papi_service_t handle, char *name,
292 		char *function)
293 {
294 	papi_status_t result = PAPI_INTERNAL_ERROR;
295 	service_t *svc = handle;
296 	papi_status_t (*f)();
297 
298 	if ((svc == NULL) || (name == NULL))
299 		return (PAPI_BAD_ARGUMENT);
300 
301 	if ((result = service_connect(svc, name)) != PAPI_OK)
302 		return (result);
303 
304 	f = (papi_status_t (*)())psm_sym(svc, function);
305 	if (f != NULL)
306 		result = f(svc->svc_handle, svc->name);
307 
308 	return (result);
309 }
310 
311 papi_status_t
312 papiPrinterDisable(papi_service_t handle, char *name, char *message)
313 {
314 	return (_papi_printer_disable_or_pause(handle, name, message,
315 						"papiPrinterDisable"));
316 }
317 
318 papi_status_t
319 papiPrinterPause(papi_service_t handle, char *name, char *message)
320 {
321 	return (_papi_printer_disable_or_pause(handle, name, message,
322 						"papiPrinterPause"));
323 }
324 
325 papi_status_t
326 papiPrinterEnable(papi_service_t handle, char *name)
327 {
328 	return (_papi_printer_enable_or_resume(handle, name,
329 						"papiPrinterEnable"));
330 }
331 
332 papi_status_t
333 papiPrinterResume(papi_service_t handle, char *name)
334 {
335 	return (_papi_printer_enable_or_resume(handle, name,
336 						"papiPrinterResume"));
337 }
338 
339 static papi_status_t
340 _papi_printer_add_or_modify(papi_service_t handle, char *name,
341 		papi_attribute_t **attributes, papi_printer_t *printer,
342 		char *function)
343 {
344 	papi_status_t result = PAPI_INTERNAL_ERROR;
345 	service_t *svc = handle;
346 	printer_t *p = NULL;
347 	papi_status_t (*f)();
348 
349 	if ((svc == NULL) || (name == NULL) || (attributes == NULL))
350 		return (PAPI_BAD_ARGUMENT);
351 
352 	if ((result = service_connect(svc, name)) != PAPI_OK)
353 		return (result);
354 
355 	if ((*printer = p = calloc(1, sizeof (*p))) == NULL)
356 		return (PAPI_TEMPORARY_ERROR);
357 
358 	p->svc = svc;
359 	f = (papi_status_t (*)())psm_sym(p->svc, function);
360 	if (f != NULL)
361 		result = f(svc->svc_handle, svc->name, attributes,
362 				&p->printer);
363 
364 	return (result);
365 }
366 
367 papi_status_t
368 papiPrinterAdd(papi_service_t handle, char *name,
369 		papi_attribute_t **attributes, papi_printer_t *printer)
370 {
371 	return (_papi_printer_add_or_modify(handle, name, attributes, printer,
372 						"papiPrinterAdd"));
373 }
374 
375 papi_status_t
376 papiPrinterModify(papi_service_t handle, char *name,
377 		papi_attribute_t **attributes, papi_printer_t *printer)
378 {
379 	return (_papi_printer_add_or_modify(handle, name, attributes, printer,
380 						"papiPrinterModify"));
381 }
382 
383 
384 papi_status_t
385 papiPrinterRemove(papi_service_t handle, char *name)
386 {
387 	papi_status_t result = PAPI_INTERNAL_ERROR;
388 	service_t *svc = handle;
389 	papi_status_t (*f)();
390 
391 	if ((svc == NULL) || (name == NULL))
392 		return (PAPI_BAD_ARGUMENT);
393 
394 	if ((result = service_connect(svc, name)) != PAPI_OK)
395 		return (result);
396 
397 	f = (papi_status_t (*)())psm_sym(svc, "papiPrinterRemove");
398 	if (f != NULL)
399 		result = f(svc->svc_handle, svc->name);
400 
401 	return (result);
402 }
403 
404 papi_status_t
405 papiPrinterPurgeJobs(papi_service_t handle, char *name, papi_job_t **jobs)
406 {
407 	papi_status_t result = PAPI_INTERNAL_ERROR;
408 	service_t *svc = handle;
409 	papi_job_t *svc_jobs = NULL;
410 	papi_status_t (*f)();
411 
412 	if ((svc == NULL) || (name == NULL))
413 		return (PAPI_BAD_ARGUMENT);
414 
415 	if ((result = service_connect(svc, name)) != PAPI_OK)
416 		return (result);
417 
418 	f = (papi_status_t (*)())psm_sym(svc, "papiPrinterPurgeJobs");
419 	if (f != NULL)
420 		result = f(svc->svc_handle, svc->name, &svc_jobs);
421 
422 	/*
423 	 * copy the resulting job object pointers into our own
424 	 * representation of a job object because we need the
425 	 * service context to operate against the individual job
426 	 * objects.  We free the list now because we no longer need
427 	 * it and would have no way of freeing it later.
428 	 */
429 	if ((result == PAPI_OK) && (svc_jobs != NULL) && (jobs != NULL)) {
430 		int i;
431 
432 		*jobs = NULL;
433 		for (i = 0; svc_jobs[i] != NULL; i++) {
434 			job_t *j = NULL;
435 
436 			if ((j = calloc(1, sizeof (*j))) == NULL)
437 				return (PAPI_TEMPORARY_ERROR);
438 
439 			j->svc = svc;
440 			j->job = svc_jobs[i];
441 			list_append(jobs, j);
442 		}
443 		free(svc_jobs);
444 	}
445 
446 	return (result);
447 }
448 
449 papi_status_t
450 papiPrinterListJobs(papi_service_t handle, char *name, char **requested_attrs,
451 		int type_mask, int max_num_jobs, papi_job_t **jobs)
452 {
453 	papi_status_t result = PAPI_INTERNAL_ERROR;
454 	service_t *svc = handle;
455 	papi_job_t *svc_jobs = NULL;
456 	papi_status_t (*f)();
457 
458 	if ((svc == NULL) || (name == NULL) || (jobs == NULL))
459 		return (PAPI_BAD_ARGUMENT);
460 
461 	if ((result = service_connect(svc, name)) != PAPI_OK)
462 		return (result);
463 
464 	f = (papi_status_t (*)())psm_sym(svc, "papiPrinterListJobs");
465 	if (f != NULL)
466 		result = f(svc->svc_handle, svc->name, requested_attrs,
467 				type_mask, max_num_jobs, &svc_jobs);
468 
469 	/*
470 	 * copy the resulting job object pointers into our own
471 	 * representation of a job object because we need the
472 	 * service context to operate against the individual job
473 	 * objects.  We free the list now because we no longer need
474 	 * it and would have no way of freeing it later.
475 	 */
476 	if ((result == PAPI_OK) && (svc_jobs != NULL)) {
477 		int i;
478 
479 		*jobs = NULL;
480 		for (i = 0; svc_jobs[i] != NULL; i++) {
481 			job_t *j = NULL;
482 
483 			if ((j = calloc(1, sizeof (*j))) == NULL)
484 				return (PAPI_TEMPORARY_ERROR);
485 
486 			j->svc = svc;
487 			j->job = svc_jobs[i];
488 			list_append(jobs, j);
489 		}
490 		free(svc_jobs);
491 	}
492 
493 	return (result);
494 }
495 
496 papi_attribute_t **
497 papiPrinterGetAttributeList(papi_printer_t printer)
498 {
499 	papi_attribute_t **result = NULL;
500 	printer_t *p = printer;
501 
502 	if ((p != NULL) && (p->printer != NULL)) {
503 		papi_attribute_t **(*f)();
504 
505 		f = (papi_attribute_t **(*)())psm_sym(p->svc,
506 					"papiPrinterGetAttributeList");
507 		if (f != NULL)
508 			result = f(p->printer);
509 	} else
510 		result = p->attributes;
511 
512 	return (result);
513 }
514