/*
 * 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.
 */

#pragma weak _nss_ldap__printers_constr = _nss_ldap_printers_constr

#include "ldap_common.h"

static void append_attr(char *buf, char *attr);

/* printer attributes filters */
#define	_F_GETPRINTERBYNAME	\
	"(&(objectClass=sunPrinter)(|(printer-name=%s)(printer-aliases=%s)))"

#define	PRINTER_PREFIX	"printer-"
#define	SUNWPR_PREFIX	"sunwpr-"

/*
 * Attributes from the following classes:
 * 	printerService
 * 	printerAbstact
 * 	sunPrinter
 */

/*
 * Get all attributes.
 */
static const char **printer_attrs = NULL;


/*
 * _nss_ldap_printers2str is the data marshaling method for the printers
 * getXbyY backend processes. This method is called after a successful
 * ldap search has been performed. This method will parse the ldap search
 * values into argp->buf.buffer. Three error conditions are expected and
 * returned to nsswitch.
 * In order to be compatible with old data output, the code is commented out
 * with NSS_LDAP_PRINTERS. The NSS_LDAP_PRINTERS section is for future
 * refrences if it's decided to fix the output format.
 */

static int
_nss_ldap_printers2str(ldap_backend_ptr be, nss_XbyY_args_t *argp)
{
	int			i, j;
	int			nss_result;
	int			buflen = 0, len;
	char			*buffer = NULL;
	char			**name, *attrname;
	ns_ldap_attr_t		*attr;
	ns_ldap_result_t	*result = be->result;
#ifdef	NSS_LDAP_PRINTERS
	int			slen, plen;
#endif

	if (result == NULL)
		return (NSS_STR_PARSE_PARSE);

	buflen = argp->buf.buflen;
	if (argp->buf.result != NULL) {
		be->buffer = calloc(1, buflen);
		if (be->buffer == NULL)
			return (NSS_STR_PARSE_PARSE);
		be->buflen = buflen;
		buffer = be->buffer;
	} else {
		buffer = argp->buf.buffer;
		(void) memset(argp->buf.buffer, 0, buflen);
	}

	nss_result = NSS_STR_PARSE_SUCCESS;

#ifdef	NSS_LDAP_PRINTERS
	slen = strlen(SUNWPR_PREFIX);
	plen = strlen(PRINTER_PREFIX);
#endif

	/*
	 * Pick out the printer name and aliases
	 */
	name = __ns_ldap_getAttr(result->entry, "printer-name");
	if (name == NULL || name[0] == NULL) {
		nss_result = NSS_STR_PARSE_PARSE;
		goto result_printers2str;
	}
	len = snprintf(buffer, buflen, "%s", name[0]);
	TEST_AND_ADJUST(len, buffer, buflen, result_printers2str);

#ifdef	NSS_LDAP_PRINTERS
	attr = __ns_ldap_getAttrStruct(result->entry, "printer-aliases");
	if (attr != NULL && attr->attrvalue != NULL) {
		for (i = 0; i < attr->value_count; i++) {
			len = snprintf(buffer, buflen, "|%s",
					attr->attrvalue[i]);
			TEST_AND_ADJUST(len, buffer, buflen,
					result_printers2str);
		}
	}
#endif
	/*
	 * Add the rest of the attributes
	 */
	for (i = 0; i < result->entry->attr_count; i++) {
		attr = getattr(result, i);
		if (attr == NULL) {
			nss_result = NSS_STR_PARSE_PARSE;
			goto result_printers2str;
		}
		/*
		 * The attribute contains key=value
		 */
		if (strcasecmp(attr->attrname, "sun-printer-kvp") == 0) {
			for (j = 0; j < attr->value_count; j++) {
				len = strlen(attr->attrvalue[j]);
				if (len < 1 ) {
					*buffer = '\0';
					nss_result = (int)NSS_STR_PARSE_PARSE;
					goto result_printers2str;
				}
				len =  snprintf(buffer, buflen, ":%s",
						attr->attrvalue[j]);
				TEST_AND_ADJUST(len, buffer, buflen,
						result_printers2str);
			}
		} else {
			/*
			 * Skip some attr names
			 */
#ifdef	NSS_LDAP_PRINTERS
			if (strcasecmp(attr->attrname, "printer-name") == 0 ||
				strcasecmp(attr->attrname, "dn") == 0 ||
				strcasecmp(attr->attrname,
					"objectclass") == 0 ||
				strcasecmp(attr->attrname,
					"printer-uri") == 0 ||
				strcasecmp(attr->attrname,
					"printer-aliases") == 0)
#else
			if (strcasecmp(attr->attrname, "printer-name") == 0)
#endif
				continue;
			}
			/*
			 * Translate attr name ->key name
			 */
			if (strcmp(attr->attrname, "sun-printer-bsdaddr")
					== 0)
				attrname = "bsdaddr";
#ifdef	NSS_LDAP_PRINTERS
			else if (strcmp(attr->attrname, "printer-info")
					== 0)
				attrname = "description";
			else if (strcmp(attr->attrname, "sunwpr-support")
					== 0)
				attrname = "itopssupported";
			else if (strncmp(attr->attrname, PRINTER_PREFIX, plen)
					== 0)
				attrname = attr->attrname + plen;
			else if (strncmp(attr->attrname, SUNWPR_PREFIX, slen)
					== 0)
				attrname = attr->attrname + slen;
#endif
			else
				attrname = attr->attrname;

			/*
			 * The attrname is the key. The attribute
			 * data is the value.
			 */
			len = snprintf(buffer, buflen, ":%s=", attrname);
			TEST_AND_ADJUST(len, buffer, buflen,
					result_printers2str);

			for (j = 0; j < attr->value_count; j++) {
				int k;
				char *kp;

				if (attr->attrvalue[j] == NULL) {
					*buffer = 0;
					nss_result = NSS_STR_PARSE_PARSE;
					goto result_printers2str;
				}
				len = strlen(attr->attrvalue[j]);
				if (len < 1) {
					*buffer = 0;
					nss_result = NSS_STR_PARSE_PARSE;
					goto result_printers2str;
				}
				/*
				 * Add extra for any colons which need to
				 * be backslashed plus ending ':' or ','.
				 */
				k = 0;
				for (kp = attr->attrvalue[j]; *kp != '\0'; kp++)
					if (*kp == ':')
						/* count ':' in value */
						k++;
				if (j == 0)
					/* first time */
					len += k;
				else
					/* add ',' */
					len += k + 1;

				if (len > buflen) {
					nss_result = NSS_STR_PARSE_ERANGE;
					goto result_printers2str;
				}
				if (j > 0)
					*buffer++ = ',';

				(void) append_attr(buffer,
					    attr->attrvalue[j]);
				buffer += strlen(attr->attrvalue[j]) + k;
				buflen -= len;
			}
	}

	if (argp->buf.result != NULL)
		be->buflen = strlen(be->buffer);

result_printers2str:
	(void) __ns_ldap_freeResult(&be->result);
	return ((int)nss_result);
}

/*
 * Attributes which contain colons must be backslashed.
 */
static void
append_attr(char *buf, char *attr)
{
	char *cp, *bp;

	if (strchr(attr, ':') == NULL) {
		(void) strcat(buf, attr);
		return;
	}
	bp = buf;
	cp = attr;
	while (*cp != '\0') {
		if (*cp == ':') {
			*bp++ = '\\';
		}
		*bp++ = *cp++;
	}
}

/*
 * getbyname gets printer attributes by printer name. This function
 * constructs an ldap search filter using the printer name invocation
 * parameter and the getprinterbyname search filter defined. Once the
 * filter is constructed, we search for matching entries and marshal
 * the data results into argp->buf.buffer for the frontend process.
 * The function _nss_ldap_printers2str performs the data marshaling.
 */

static nss_status_t
getbyname(ldap_backend_ptr be, void *a)
{
	char		printername[BUFSIZ];
	nss_XbyY_args_t	*argp = (nss_XbyY_args_t *)a;
	char		searchfilter[SEARCHFILTERLEN];

	(void) strncpy(printername, argp->key.name, BUFSIZ);
	if (snprintf(searchfilter, SEARCHFILTERLEN,
		_F_GETPRINTERBYNAME, printername, printername) < 0)
		return ((nss_status_t)NSS_NOTFOUND);

	return ((nss_status_t)_nss_ldap_lookup(be, argp,
		_PRINTERS, searchfilter, NULL, NULL, NULL));
}

static ldap_backend_op_t printers_ops[] = {
	_nss_ldap_destr,
	_nss_ldap_endent,
	_nss_ldap_setent,
	_nss_ldap_getent,
	getbyname,
};


/*
 * _nss_ldap_printers_constr is where life begins. This function calls
 * the generic ldap constructor function to define and build the abstract
 * data types required to support ldap operations.
 */

/*ARGSUSED0*/
nss_backend_t *
_nss_ldap_printers_constr(const char *dummy1, const char *dummy2,
			const char *dummy3)
{

	return ((nss_backend_t *)_nss_ldap_constr(printers_ops,
		sizeof (printers_ops)/sizeof (printers_ops[0]), _PRINTERS,
		printer_attrs, _nss_ldap_printers2str));
}