xref: /titanic_53/usr/src/lib/print/libpapi-dynamic/common/printer.c (revision b51e021de072d76292addb44467f777617c6a8c1)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 */

/* $Id: printer.c 151 2006-04-25 16:55:34Z njacobs $ */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*LINTLIBRARY*/

#include <stdlib.h>
#include <papi_impl.h>

void
papiPrinterFree(papi_printer_t printer)
{
	printer_t *tmp = printer;

	if (tmp != NULL) {
		void (*f)();

		f = (void (*)())psm_sym(tmp->svc, "papiPrinterFree");
		if (f != NULL)
			f(tmp->printer);
		if (tmp->attributes != NULL)
			papiAttributeListFree(tmp->attributes);
		if (tmp->svc_is_internal != 0)
			papiServiceDestroy(tmp->svc);
		free(tmp);
	}
}

void
papiPrinterListFree(papi_printer_t *printers)
{
	if (printers != NULL) {
		int i;

		for (i = 0; printers[i] != NULL; i++)
			papiPrinterFree(printers[i]);
		free(printers);
	}
}

/* Enumerate a list of printers from the loaded print service. */
static papi_status_t
printers_from_service(service_t *svc, char **requested_attrs,
		papi_filter_t *filter, papi_printer_t **printers)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	papi_printer_t *svc_printers = NULL;
	papi_status_t (*f)();

	if ((svc == NULL) || (printers == NULL))
		return (PAPI_BAD_ARGUMENT);

	/* connect to the service if we are not connected */
	if ((result = service_connect(svc, svc->name)) != PAPI_OK)
		return (result);

	f = (papi_status_t (*)())psm_sym(svc, "papiPrintersList");
	if (f != NULL)
		result = f(svc->svc_handle, requested_attrs, filter,
				&svc_printers);

	/*
	 * copy the resulting printer object pointers into our own
	 * representation of a printer object because we need the
	 * service context to operate against the individual printer
	 * objects.  We free the list now because we no longer need
	 * it and would have no way of freeing it later.
	 */
	if ((result == PAPI_OK) && (svc_printers != NULL)) {
		int i;

		*printers = NULL;
		for (i = 0; svc_printers[i] != NULL; i++) {
			printer_t *p = NULL;

			if ((p = calloc(1, sizeof (*p))) == NULL)
				return (PAPI_TEMPORARY_ERROR);

			p->svc = svc;
			p->printer = svc_printers[i];
			list_append(printers, p);
		}
		free(svc_printers);
	}

	return (result);
}

/* Get printer attributes from it's print service */
static papi_status_t
printer_from_service(service_t *svc, printer_t *p, char **requested_attrs)
{
	papi_status_t result;
	papi_service_t p_svc = NULL;
	papi_printer_t printer = NULL;
	char *psm = NULL;
	char *uri = NULL;

	/* get the psm and uri from the attributes */
	papiAttributeListGetString(p->attributes, NULL,
			"print-service-module", &psm);
	papiAttributeListGetString(p->attributes, NULL, "printer-name", &uri);
	papiAttributeListGetString(p->attributes, NULL, "printer-uri-supported",
			&uri);

	/* contact the service for the printer */
	result = papiServiceCreate((papi_service_t *)&p_svc, psm, svc->user,
				svc->password, svc->authCB, svc->encryption,
				svc->app_data);
	if (result != PAPI_OK)
		return (result);

	/* get the printer from the service */
	result = papiPrinterQuery(p_svc, uri, requested_attrs, NULL, &printer);
	if (result == PAPI_OK) {
		papi_attribute_t **attributes;

		attributes = papiPrinterGetAttributeList(printer);
		copy_attributes(&p->attributes, attributes);
	}
	papiPrinterFree(printer);
	papiServiceDestroy(p_svc);

	return (result);
}

/* are the requested attributes contained in the list */
static int
contained(char **requested, papi_attribute_t **list)
{
	int i;

	if (requested == NULL)	/* we want every possible attribute */
		return (0);

	for (i = 0; requested[i] != NULL; i++)
		if (papiAttributeListFind(list, requested[i]) == NULL)
			return (0);

	return (1);
}

/* Enumerate a list of printers from the Name Service */
static papi_status_t
printers_from_name_service(service_t *svc, char **requested_attrs,
		papi_filter_t *filter, papi_printer_t **printers)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	papi_attribute_t **attrs;

	if ((svc == NULL) || (printers == NULL))
		return (PAPI_BAD_ARGUMENT);

	/* retrieve printers from the nameservice */
	setprinterentry(0, NULL);
	while ((attrs = getprinterentry(NULL)) != NULL) {
		printer_t *p = NULL;

		if ((p = calloc(1, sizeof (*p))) == NULL)
			return (PAPI_TEMPORARY_ERROR);

		p->attributes = attrs;
		list_append(printers, p);
	}

	/* if we have printers, check if our request has been satisfied */
	if ((printers != NULL) && (*printers != NULL)) {
		int i;

		/* walk through the list */
		for (i = 0; (*printers)[i] != NULL; i++) {
			printer_t *p = (*printers)[i];

			/* see if the name service satisfied the request */
			if (contained(requested_attrs, p->attributes) == 0)
				printer_from_service(svc, p, requested_attrs);
		}
	}

	return (PAPI_OK);
}

papi_status_t
papiPrintersList(papi_service_t handle, char **requested_attrs,
		papi_filter_t *filter, papi_printer_t **printers)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	service_t *svc = handle;
	papi_printer_t *svc_printers = NULL;
	papi_status_t (*f)();

	if ((svc == NULL) || (printers == NULL))
		return (PAPI_BAD_ARGUMENT);

	if (svc->so_handle != NULL)	/* connected, use the print svc */
		result = printers_from_service(svc, requested_attrs,
					filter, printers);
	else				/* not connected, use the name svc */
		result = printers_from_name_service(svc, requested_attrs,
					filter, printers);

	return (result);
}

papi_status_t
papiPrinterQuery(papi_service_t handle, char *name, char **requested_attrs,
		papi_attribute_t **job_attributes, papi_printer_t *printer)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	service_t *svc = handle;
	printer_t *p = NULL;
	papi_status_t (*f)();

	if ((svc == NULL) || (name == NULL) || (printer == NULL))
		return (PAPI_BAD_ARGUMENT);

	if ((result = service_connect(svc, name)) != PAPI_OK)
		return (result);

	if ((*printer = p = calloc(1, sizeof (*p))) == NULL)
		return (PAPI_TEMPORARY_ERROR);

	if ((svc->name != NULL) && (svc->svc_handle != NULL) &&
	    (svc->uri != NULL)) {
		p->svc = svc;
		f = (papi_status_t (*)())psm_sym(p->svc, "papiPrinterQuery");
		if (f != NULL)
			result = f(svc->svc_handle, svc->name, requested_attrs,
					job_attributes, &p->printer);
	} else {
		setprinterentry(0, NULL);
		p->attributes = getprinterbyname(name, NULL);
		if (p->attributes == NULL)
			result = PAPI_NOT_FOUND;
		else
			result = PAPI_OK;
	}

	return (result);
}

static papi_status_t
_papi_printer_disable_or_pause(papi_service_t handle, char *name, char *message,
		char *function)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	service_t *svc = handle;
	papi_status_t (*f)();

	if ((svc == NULL) || (name == NULL))
		return (PAPI_BAD_ARGUMENT);

	if ((result = service_connect(svc, name)) != PAPI_OK)
		return (result);

	f = (papi_status_t (*)())psm_sym(svc, function);
	if (f != NULL)
		result = f(svc->svc_handle, svc->name, message);

	return (result);
}

static papi_status_t
_papi_printer_enable_or_resume(papi_service_t handle, char *name,
		char *function)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	service_t *svc = handle;
	papi_status_t (*f)();

	if ((svc == NULL) || (name == NULL))
		return (PAPI_BAD_ARGUMENT);

	if ((result = service_connect(svc, name)) != PAPI_OK)
		return (result);

	f = (papi_status_t (*)())psm_sym(svc, function);
	if (f != NULL)
		result = f(svc->svc_handle, svc->name);

	return (result);
}

papi_status_t
papiPrinterDisable(papi_service_t handle, char *name, char *message)
{
	return (_papi_printer_disable_or_pause(handle, name, message,
						"papiPrinterDisable"));
}

papi_status_t
papiPrinterPause(papi_service_t handle, char *name, char *message)
{
	return (_papi_printer_disable_or_pause(handle, name, message,
						"papiPrinterPause"));
}

papi_status_t
papiPrinterEnable(papi_service_t handle, char *name)
{
	return (_papi_printer_enable_or_resume(handle, name,
						"papiPrinterEnable"));
}

papi_status_t
papiPrinterResume(papi_service_t handle, char *name)
{
	return (_papi_printer_enable_or_resume(handle, name,
						"papiPrinterResume"));
}

static papi_status_t
_papi_printer_add_or_modify(papi_service_t handle, char *name,
		papi_attribute_t **attributes, papi_printer_t *printer,
		char *function)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	service_t *svc = handle;
	printer_t *p = NULL;
	papi_status_t (*f)();

	if ((svc == NULL) || (name == NULL) || (attributes == NULL))
		return (PAPI_BAD_ARGUMENT);

	if ((result = service_connect(svc, name)) != PAPI_OK)
		return (result);

	if ((*printer = p = calloc(1, sizeof (*p))) == NULL)
		return (PAPI_TEMPORARY_ERROR);

	p->svc = svc;
	f = (papi_status_t (*)())psm_sym(p->svc, function);
	if (f != NULL)
		result = f(svc->svc_handle, svc->name, attributes,
				&p->printer);

	return (result);
}

papi_status_t
papiPrinterAdd(papi_service_t handle, char *name,
		papi_attribute_t **attributes, papi_printer_t *printer)
{
	return (_papi_printer_add_or_modify(handle, name, attributes, printer,
						"papiPrinterAdd"));
}

papi_status_t
papiPrinterModify(papi_service_t handle, char *name,
		papi_attribute_t **attributes, papi_printer_t *printer)
{
	return (_papi_printer_add_or_modify(handle, name, attributes, printer,
						"papiPrinterModify"));
}


papi_status_t
papiPrinterRemove(papi_service_t handle, char *name)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	service_t *svc = handle;
	papi_status_t (*f)();

	if ((svc == NULL) || (name == NULL))
		return (PAPI_BAD_ARGUMENT);

	if ((result = service_connect(svc, name)) != PAPI_OK)
		return (result);

	f = (papi_status_t (*)())psm_sym(svc, "papiPrinterRemove");
	if (f != NULL)
		result = f(svc->svc_handle, svc->name);

	return (result);
}

papi_status_t
papiPrinterPurgeJobs(papi_service_t handle, char *name, papi_job_t **jobs)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	service_t *svc = handle;
	papi_job_t *svc_jobs = NULL;
	papi_status_t (*f)();

	if ((svc == NULL) || (name == NULL))
		return (PAPI_BAD_ARGUMENT);

	if ((result = service_connect(svc, name)) != PAPI_OK)
		return (result);

	f = (papi_status_t (*)())psm_sym(svc, "papiPrinterPurgeJobs");
	if (f != NULL)
		result = f(svc->svc_handle, svc->name, &svc_jobs);

	/*
	 * copy the resulting job object pointers into our own
	 * representation of a job object because we need the
	 * service context to operate against the individual job
	 * objects.  We free the list now because we no longer need
	 * it and would have no way of freeing it later.
	 */
	if ((result == PAPI_OK) && (svc_jobs != NULL) && (jobs != NULL)) {
		int i;

		*jobs = NULL;
		for (i = 0; svc_jobs[i] != NULL; i++) {
			job_t *j = NULL;

			if ((j = calloc(1, sizeof (*j))) == NULL)
				return (PAPI_TEMPORARY_ERROR);

			j->svc = svc;
			j->job = svc_jobs[i];
			list_append(jobs, j);
		}
		free(svc_jobs);
	}

	return (result);
}

papi_status_t
papiPrinterListJobs(papi_service_t handle, char *name, char **requested_attrs,
		int type_mask, int max_num_jobs, papi_job_t **jobs)
{
	papi_status_t result = PAPI_INTERNAL_ERROR;
	service_t *svc = handle;
	papi_job_t *svc_jobs = NULL;
	papi_status_t (*f)();

	if ((svc == NULL) || (name == NULL) || (jobs == NULL))
		return (PAPI_BAD_ARGUMENT);

	if ((result = service_connect(svc, name)) != PAPI_OK)
		return (result);

	f = (papi_status_t (*)())psm_sym(svc, "papiPrinterListJobs");
	if (f != NULL)
		result = f(svc->svc_handle, svc->name, requested_attrs,
				type_mask, max_num_jobs, &svc_jobs);

	/*
	 * copy the resulting job object pointers into our own
	 * representation of a job object because we need the
	 * service context to operate against the individual job
	 * objects.  We free the list now because we no longer need
	 * it and would have no way of freeing it later.
	 */
	if ((result == PAPI_OK) && (svc_jobs != NULL)) {
		int i;

		*jobs = NULL;
		for (i = 0; svc_jobs[i] != NULL; i++) {
			job_t *j = NULL;

			if ((j = calloc(1, sizeof (*j))) == NULL)
				return (PAPI_TEMPORARY_ERROR);

			j->svc = svc;
			j->job = svc_jobs[i];
			list_append(jobs, j);
		}
		free(svc_jobs);
	}

	return (result);
}

papi_attribute_t **
papiPrinterGetAttributeList(papi_printer_t printer)
{
	papi_attribute_t **result = NULL;
	printer_t *p = printer;

	if ((p != NULL) && (p->printer != NULL)) {
		papi_attribute_t **(*f)();

		f = (papi_attribute_t **(*)())psm_sym(p->svc,
					"papiPrinterGetAttributeList");
		if (f != NULL)
			result = f(p->printer);
	} else
		result = p->attributes;

	return (result);
}