/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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
 */
#pragma ident	"%Z%%M%	%I%	%E% SMI"
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*LINTLIBRARY*/

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <unistd.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <rpcsvc/ypclnt.h>

char glob_stdout[BUFSIZ];
char glob_stderr[BUFSIZ];

void f_cleanup(FILE *fp, char *tmpf);
void fd_cleanup(int fd1, int fd2);
static void _freeList(char ***list);

extern void **list_append(void **list, void *item);

#ifdef MAIN

#define	THOSTNAME "cherwell"
#define	TPRINTERNAME "c"

int
main() {
	char *host = THOSTNAME;
	const char *user = "cn=Directory Manager";
	const char *passwd = "directorymanager";
	int result = 0;

	result = _updateldap("add", host, user, passwd,
		    "_pmTestAuthToken", NULL, NULL, "new comment", "false");
	if (result != 0) {
		printf("Add 1 failed, err code = %d\n");
	}

	result = _updateldap("delete", host, user, passwd,
		    "_pmTestAuthToken", NULL, NULL, NULL, "false");
	if (result != 0) {
		printf("Delete 1 failed, err code = %d\n");
	}

	result = _updateldap("delete", host, user, passwd, TPRINTERNAME,
			THOSTNAME, "", "new comment", "true");
	if (result != 0) {
		printf("delete failed, err code = %d\n");
	}

	result = _updateldap("delete", host, user, passwd, "_default",
			THOSTNAME, "", "new comment", "true");
	if (result != 0) {
		printf("delete failed, err code = %d\n");
	}

	result = _updateldap("add", host, user, passwd, TPRINTERNAME,
			THOSTNAME, "Solaris", "new comment", "true");
	if (result != 0) {
		printf("add failed, err code = %d\n");
	}

	result = _updateldap("modify", host, user, passwd, TPRINTERNAME,
			THOSTNAME, "", "modified comment", "true");
	if (result != 0) {
		printf("modify failed, err code = %d\n");
	}

	result = _updateldap("modify", host, user, passwd, TPRINTERNAME,
			THOSTNAME, "", NULL, "false");
	if (result != 0) {
		printf("modify failed, err code = %d\n");
	}


	exit(0);
}
#endif


int
_dorexec(
	const char *host,
	const char *user,
	const char *passwd,
	const char *cmd,
	const char *locale) {

	int ret = 0;
	int fd = 0;
	int fd2 = 1;

	FILE *fderr;
	char *ferr;

	(void) memset(glob_stdout, 0, BUFSIZ);
	(void) memset(glob_stderr, 0, BUFSIZ);

	/*
	 * Re-direct stderr to a file
	 */
	ferr = tempnam(NULL, NULL);
	if (ferr != NULL) {
		fderr = freopen(ferr, "w+", stderr);
	}

	fd = rexec((char **)&host, htons(512), user,
	    passwd, cmd, &fd2);

	if (fd > -1) {
		/*
		 * rexec worked. Clean up stderr file.
		 */
		f_cleanup(fderr, ferr);

		ret = read(fd, glob_stdout, BUFSIZ - 1);
		if (ret < 0) {
			(void) strncpy(glob_stderr, strerror(errno),
			    (BUFSIZ - 1));
			fd_cleanup(fd, fd2);
			return (errno);
		}

		ret = read(fd2, glob_stderr, BUFSIZ - 1);
		if (ret < 0) {
			(void) strncpy(glob_stderr, strerror(errno),
			    (BUFSIZ - 1));
			fd_cleanup(fd, fd2);
			return (errno);
		}
	} else {
		/*
		 * rexec failed. Read from the stderr file.
		 */
		if (fderr != NULL) {
			char tmpbuf[BUFSIZ];

			(void) rewind(fderr);
			strcpy(glob_stderr, "");
			while (fgets(tmpbuf, BUFSIZ - 1,
			    fderr) != NULL) {
				if ((strlen(glob_stderr) +
				    strlen(tmpbuf)) > BUFSIZ - 1) {
					break;
				} else {
					(void) strcat(glob_stderr, tmpbuf);
				}
			}
		}
		f_cleanup(fderr, ferr);
		fd_cleanup(fd, fd2);
		return (1);
	}
	fd_cleanup(fd, fd2);
	return (0);
}

void
fd_cleanup(int fd, int fd2)
{
	if (fd > 0) {
		(void) close(fd);
	}
	if (fd2 > 0) {
		(void) close(fd2);
	}
}

void
f_cleanup(FILE *fp, char *tmpf)
{
	if (fp != NULL) {
		(void) fclose(fp);
	}
	if (tmpf != NULL) {
		(void) unlink(tmpf);
		(void) free(tmpf);
	}
}

struct ns_bsd_addr {
	char  *server;		/* server name */
	char  *printer;		/* printer name or NULL */
	char  *extension;	/* RFC-1179 conformance */
	char  *pname;		/* Local printer name */
};
typedef struct ns_bsd_addr ns_bsd_addr_t;

/* Key/Value pair structure */
struct ns_kvp {
	char *key;	/* key */
	void *value;	/* value converted */
};
typedef struct ns_kvp ns_kvp_t;

/*
 * Information needed to update a name service.
 * Currently only used for ldap. (see lib/print/ns.h)
 */

/* LDAP bind password security type */

typedef enum NS_PASSWD_TYPE {
	NS_PW_INSECURE = 0,
	NS_PW_SECURE = 1
} NS_PASSWD_TYPE;


struct ns_cred {
	char	*binddn;
	char	*passwd;
	char	*host;
	int	port;			/* LDAP port, 0 = default */
	NS_PASSWD_TYPE passwdType;	/* password security type */
	uchar_t  *domainDN;		/* NS domain DN */
};
typedef struct ns_cred ns_cred_t;

/* LDAP specific NS Data */

typedef struct NS_LDAPDATA {
	char **attrList;	/* list of user defined Key Value Pairs */
} NS_LDAPDATA;

/* Printer Object structure */
struct ns_printer {
	char	*name;		/* primary name of printer */
	char	**aliases;	/* aliases for printer */
	char	*source;	/* name service derived from */
	ns_kvp_t	**attributes;	/* key/value pairs. */
	ns_cred_t	*cred;	/* info to update name service */
	void	*nsdata;	/* name service specific data */
};
typedef struct ns_printer ns_printer_t;

extern ns_printer_t *ns_printer_get_name(const char *, const char *);
extern int ns_printer_put(const ns_printer_t *);
extern char *ns_get_value_string(const char *, const ns_printer_t *);
extern int ns_set_value(const char *, const void *, ns_printer_t *);
extern int ns_set_value_from_string(const char *, const char *,
					ns_printer_t *);
extern ns_bsd_addr_t *bsd_addr_create(const char *, const char *,
					const char *);
extern char *bsd_addr_to_string(const ns_bsd_addr_t *);
extern void ns_printer_destroy(ns_printer_t *);

int
_updateoldyp(
	const char *action,
	const char *printername,
	const char *printserver,
	const char *extensions,
	const char *comment,
	const char *isdefault) {

	ns_printer_t *printer;
	ns_bsd_addr_t *addr;
	int status = 0;

	char mkcmd[BUFSIZ];
	char *domain = NULL;
	char *host = NULL;

	/*
	 * libprint returns before we know that the printers.conf
	 * map is made. So we'll make it again.
	 */
	(void) yp_get_default_domain(&domain);

	if ((yp_master(domain, "printers.conf.byname", &host) != 0) &&
	    (yp_master(domain, "passwd.byname", &host) != 0)) {
		strcpy(mkcmd, "/usr/bin/sleep 1");
	} else {
		sprintf(mkcmd, "/usr/bin/rsh -n %s 'cd /var/yp; "
				"/usr/ccs/bin/make -f /var/yp/Makefile "
				"-f /var/yp/Makefile.print printers.conf "
				"> /dev/null'", host);
	}

	if (strcmp(action, "delete") == 0) {
		if ((printer = (ns_printer_t *)
		    ns_printer_get_name(printername, "nis")) == NULL) {
			return (0);
		}

		printer->attributes = NULL;
		status = ns_printer_put(printer);
		if (status != 0) {
			(void) free(printer);
			return (status);
		}

		if ((printer = (ns_printer_t *)
		    ns_printer_get_name("_default", "nis")) != NULL) {
			char *dflt = (char *)
			    ns_get_value_string("use", printer);
			if ((dflt != NULL) &&
			    (strcmp(dflt, printername) == 0)) {
				printer->attributes = NULL;
				status = ns_printer_put(printer);
				if (status != 0) {
					(void) free(printer);
					return (status);
				}
			}
		}
		(void) free(printer);
		(void) system(mkcmd);
		return (0);

	} else if (strcmp(action, "add") == 0) {
		printer = (ns_printer_t *)malloc(sizeof (*printer));
		memset(printer, 0, sizeof (*printer));
		printer->name = (char *)printername;
		printer->source = "nis";

		addr = (ns_bsd_addr_t *)malloc(sizeof (*addr));
		memset(addr, 0, sizeof (*addr));
		addr->printer = (char *)printername;
		addr->server = (char *)printserver;
		if ((extensions != NULL) &&
		    (strlen(extensions) > 0)) {
			addr->extension = (char *)extensions;
		}
		ns_set_value("bsdaddr", addr, printer);

		if ((comment != NULL) && (strlen(comment) > 0)) {
			ns_set_value_from_string("description",
			    comment, printer);
		}
		status = ns_printer_put(printer);
		if (status != 0) {
			(void) free(addr);
			(void) free(printer);
			return (status);
		}

		if (strcmp(isdefault, "true") == 0) {
			printer->name = "_default";
			printer->attributes = NULL;
			ns_set_value_from_string("use", printername, printer);
			status = ns_printer_put(printer);
			if (status != 0) {
				(void) free(addr);
				(void) free(printer);
				return (status);
			}
		}
		(void) free(addr);
		(void) free(printer);
		(void) system(mkcmd);
		return (0);
	}

	/*
	 * Modify
	 */
	if ((printer = (ns_printer_t *)
	    ns_printer_get_name(printername, "nis")) == NULL) {
		return (1);
	}
	if ((comment != NULL) && (strlen(comment) > 0)) {
		ns_set_value_from_string("description", comment, printer);
	} else {
		ns_set_value_from_string("description",
		    NULL, printer);
	}
	status = ns_printer_put(printer);
	if (status != 0) {
		(void) free(printer);
		return (status);
	}

	if ((printer = (ns_printer_t *)
	    ns_printer_get_name("_default", "nis")) != NULL) {
		char *dflt = (char *)ns_get_value_string("use", printer);
		if (strcmp(printername, dflt) == 0) {
			if (strcmp(isdefault, "false") == 0) {
				/*
				 * We were the default printer but not
				 * any more.
				 */
				printer->attributes = NULL;
				status = ns_printer_put(printer);
				if (status != 0) {
					(void) free(printer);
					return (status);
				}
			}
		} else {
			if (strcmp(isdefault, "true") == 0) {
				ns_set_value_from_string("use",
				    printername, printer);
				status = ns_printer_put(printer);
				if (status != 0) {
					(void) free(printer);
					return (status);
				}
			}
		}
	} else {
		printer = (ns_printer_t *)malloc(sizeof (*printer));
		memset(printer, 0, sizeof (*printer));
		printer->name = "_default";
		printer->source = "nis";
		ns_set_value_from_string("use", printername, printer);
		status = ns_printer_put(printer);
		if (status != 0) {
			(void) free(printer);
			return (status);
		}
	}
	(void) system(mkcmd);
	return (0);
}

int
_updateldap(
	const char *action,
	const char *host,
	const char *binddn,
	const char *passwd,
	const char *printername,
	const char *printserver,
	const char *extensions,
	const char *comment,
	const char *isdefault)

{
	ns_printer_t *printer;
	ns_bsd_addr_t *addr;
	ns_cred_t *cred;

	char *item = NULL;
	char **attrList = NULL;

	int status;

	if (printserver == NULL) {
		/* printserver not given so use host */
		printserver = host;
	}

	cred = (ns_cred_t *)malloc(sizeof (*cred));
	(void) memset(cred, '\0', sizeof (*cred));
	cred->passwd = strdup((char *)passwd);
	cred->binddn = strdup((char *)binddn);
	cred->host = strdup((char *)host);

	cred->passwdType = NS_PW_INSECURE; /* use default */
	cred->port = 0;		/* use default */
	cred->domainDN = NULL;	/* use default */

	if (strcmp(action, "delete") == 0) {
		/*
		 * Delete printer object from LDAP directory DIT
		 */

		if ((printer = (ns_printer_t *)
		    ns_printer_get_name(printername, "ldap")) == NULL) {
			return (0);
		}

		printer->attributes = NULL;
		printer->nsdata = malloc(sizeof (NS_LDAPDATA));
		if (printer->nsdata == NULL) {
			return (1);
		}
		((NS_LDAPDATA *)(printer->nsdata))->attrList = NULL;
		printer->cred = cred;
		printer->source = strdup("ldap");
		status = ns_printer_put(printer);
		free(printer->nsdata);
		(void) ns_printer_destroy(printer);

		if (status != 0) {
			return (status);
		}

		if ((printer = (ns_printer_t *)
		    ns_printer_get_name("_default", "ldap")) != NULL) {
			char *dflt = (char *)
			    ns_get_value_string("use", printer);
			if ((dflt != NULL) &&
			    (strcmp(dflt, printername) == 0)) {
				printer->attributes = NULL;
				printer->nsdata = malloc(sizeof (NS_LDAPDATA));
				if (printer->nsdata == NULL) {
					(void) ns_printer_destroy(printer);
					return (1);
				}
		((NS_LDAPDATA *)(printer->nsdata))->attrList = NULL;
				printer->cred = cred;
				printer->source = strdup("ldap");
				status = ns_printer_put(printer);
				free(printer->nsdata);
				if (status != 0) {
					(void) ns_printer_destroy(printer);
					return (status);
				}
			}

			(void) ns_printer_destroy(printer);
		}
		return (0);

	} else if (strcmp(action, "add") == 0) {
		/*
		 * Add new printer object into LDAP directory DIT
		 */

		printer = (ns_printer_t *)malloc(sizeof (*printer));
		if (printer == NULL) {
			return (1);
		}
		(void) memset(printer, 0, sizeof (*printer));
		printer->name = strdup((char *)printername);
		printer->source = strdup("ldap");

		printer->cred = cred;

		/* set BSD address in attribute list */

		if (extensions == NULL) {
			item = (char *)malloc(strlen("bsdaddr") +
						strlen(printserver) +
						strlen(printername) +
						strlen("Solaris") + 6);
		} else {
			item = (char *)malloc(strlen("bsdaddr") +
						strlen(printserver) +
						strlen(printername) +
						strlen(extensions) + 6);
		}
		if (item == NULL) {
			(void) ns_printer_destroy(printer);
			return (1);
		}

		if (extensions == NULL) {
			sprintf(item, "%s=%s,%s,%s", "bsdaddr",
				printserver, printername, "Solaris");
		} else {
			sprintf(item, "%s=%s,%s,%s", "bsdaddr",
				printserver, printername, extensions);
		}

		attrList = (char **)list_append((void**)attrList,
						(void *)item);
		if ((comment != NULL) && (strlen(comment) > 0)) {
			item = (char *)malloc(strlen("description") +
							strlen(comment) + 4);
			if (item == NULL) {
				(void) ns_printer_destroy(printer);
				return (1);
			}
			sprintf(item, "%s=%s", "description", comment);
			attrList = (char **)list_append((void**)attrList,
							(void *)item);
		}

		printer->attributes = NULL;
		printer->nsdata = malloc(sizeof (NS_LDAPDATA) + 2);
		if (printer->nsdata == NULL) {
			(void) ns_printer_destroy(printer);
			return (1);
		}
		((NS_LDAPDATA *)(printer->nsdata))->attrList = attrList;

		status = ns_printer_put(printer);
		_freeList(&attrList);
		if (status != 0) {
			free(printer->nsdata);
			(void) ns_printer_destroy(printer);
			return (status);
		}

		if (strcmp(isdefault, "true") == 0) {
			(void) free(printer->name);

			printer->name = strdup("_default");
			printer->attributes = NULL;

			attrList = NULL;
			item = (char *)malloc(strlen("use") +
						strlen(printername) + 4);
			if (item == NULL) {
				(void) ns_printer_destroy(printer);
				return (1);
			}
			sprintf(item, "%s=%s", "use", printername);
			attrList = (char **)list_append((void**)attrList,
							(void *)item);

			((NS_LDAPDATA *)(printer->nsdata))->attrList = attrList;

			status = ns_printer_put(printer);
			_freeList(&attrList);
			free(printer->nsdata);
			if (status != 0) {
				(void) ns_printer_destroy(printer);
				return (status);
			}
		}
		(void) ns_printer_destroy(printer);
		return (0);
	}

	/*
	 * Modify printer object in the LDAP directory DIT
	 */

	if ((printer = (ns_printer_t *)
	    ns_printer_get_name(printername, "ldap")) == NULL) {
		return (1);
	}
	printer->cred = cred;
	printer->source = strdup("ldap");

	if ((comment != NULL) && (strlen(comment) > 0)) {
		item = (char *)malloc(strlen("description") +
						strlen(comment) + 4);
		if (item == NULL) {
			(void) ns_printer_destroy(printer);
			return (1);
		}
		sprintf(item, "%s=%s", "description", comment);
		attrList = (char **)list_append((void**)attrList, (void *)item);
	} else {
		item = (char *)malloc(strlen("description") + 4);
		if (item == NULL) {
			(void) ns_printer_destroy(printer);
			return (1);
		}
		sprintf(item, "%s=", "description");
		attrList = (char **)list_append((void**)attrList, (void *)item);
	}

	printer->attributes = NULL;
	printer->nsdata = malloc(sizeof (NS_LDAPDATA));
	if (printer->nsdata == NULL) {
		(void) ns_printer_destroy(printer);
		return (1);
	}
	((NS_LDAPDATA *)(printer->nsdata))->attrList = attrList;

	status = ns_printer_put(printer);
	_freeList(&attrList);
	free(printer->nsdata);
	if (status != 0) {
		(void) ns_printer_destroy(printer);
		return (status);
	}

	/*
	 * Handle the default printer.
	 */
	if ((printer = (ns_printer_t *)
	    ns_printer_get_name("_default", "ldap")) != NULL) {
		char *dflt = (char *)ns_get_value_string("use", printer);

		printer->source = strdup("ldap");
		printer->cred = cred;
		if (strcmp(printername, dflt) == 0) {
			if (strcmp(isdefault, "false") == 0) {
				/*
				 * We were the default printer but not
				 * any more. So delete the default entry
				 */
				printer->attributes = NULL;
				printer->nsdata = malloc(sizeof (NS_LDAPDATA));
				if (printer->nsdata == NULL) {
					(void) ns_printer_destroy(printer);
					return (1);
				}
			((NS_LDAPDATA *)(printer->nsdata))->attrList = NULL;
				status = ns_printer_put(printer);
				free(printer->nsdata);
				if (status != 0) {
					(void) ns_printer_destroy(printer);
					return (status);
				}
			}
		} else if (strcmp(isdefault, "true") == 0) {
			/*
			 * Modify this default entry to use us.
			 */
			printer->attributes = NULL;
			printer->nsdata = malloc(sizeof (NS_LDAPDATA));
			if (printer->nsdata == NULL) {
				(void) ns_printer_destroy(printer);
				return (1);
			}
			attrList = NULL;
			item = (char *)malloc(strlen("use") +
						strlen(printername) + 4);
			if (item == NULL) {
				(void) ns_printer_destroy(printer);
				return (1);
			}
			sprintf(item, "%s=%s", "use", printername);
			attrList = (char **)list_append((void**)attrList,
							(void *)item);

			((NS_LDAPDATA *)(printer->nsdata))->attrList = attrList;

			status = ns_printer_put(printer);
			_freeList(&attrList);
			free(printer->nsdata);

			if (status != 0) {
				(void) ns_printer_destroy(printer);
				return (status);
			}
		}
	} else if (strcmp(isdefault, "true") == 0) {
		/*
		 * No default entry existed and we need one.
		 */
		printer = (ns_printer_t *)malloc(sizeof (*printer));
		(void) memset(printer, 0, sizeof (*printer));
		printer->name = strdup("_default");
		printer->source = strdup("ldap");
		printer->cred = cred;

		printer->nsdata = malloc(sizeof (NS_LDAPDATA));
		if (printer->nsdata == NULL) {
			(void) ns_printer_destroy(printer);
			return (1);
		}

		attrList = NULL;
		item = (char *)malloc(strlen("use") + strlen(printername) + 4);
		if (item == NULL) {
			(void) ns_printer_destroy(printer);
			return (1);
		}
		sprintf(item, "%s=%s", "use", printername);
		attrList = (char **)list_append((void**)attrList, (void *)item);

		((NS_LDAPDATA *)(printer->nsdata))->attrList = attrList;

		status = ns_printer_put(printer);
		_freeList(&attrList);
		free(printer->nsdata);

		if (status != 0) {
			(void) ns_printer_destroy(printer);
			return (status);
		}
	}

	(void) ns_printer_destroy(printer);
	return (0);
}




/*
 * *****************************************************************************
 *
 * Function:    _freeList()
 *
 * Description: Free the list created by list_append() where the items in
 *              the list have been strdup'ed.
 *
 * Parameters:
 * Input:       char ***list   - returned set of kvp values
 *
 * Result:      void
 *
 * *****************************************************************************
 */

static void
_freeList(char ***list)

{
	int i = 0;

	/* ------ */

	if (list != NULL) {
		if (*list != NULL) {
			for (i = 0; (*list)[i] != NULL; i++) {
				free((*list)[i]);
			}
			free(*list);
		}

		*list = NULL;
	}
} /* _freeList */