OpenSolaris Launch

1 files changed, 206 insertions, 0 deletions

diff --git a/usr/src/lib/libcrypt/common/cryptio.c b/usr/src/lib/libcrypt/common/cryptio.c
new file mode 100644
index 0000000000..cc1758d967
--- /dev/null
+++ b/usr/src/lib/libcrypt/common/cryptio.c
@@ -0,0 +1,206 @@
+/*
+ * 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
+ */
+/*
+ * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*	Copyright (c) 1988 AT&T	*/
+/*	  All Rights Reserved  	*/
+
+
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#pragma weak run_setkey = _run_setkey
+#pragma weak run_crypt = _run_crypt
+#pragma weak crypt_close = _crypt_close
+#pragma weak makekey = _makekey
+
+#include "synonyms.h"
+#include "mtlib.h"
+#include <stdio.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <thread.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <strings.h>
+#include <crypt.h>
+#include "des_soft.h"
+#include "lib_gen.h"
+
+#define	READER	0
+#define	WRITER	1
+#define	KSIZE 	8
+
+/*  Global Variables  */
+static char key[KSIZE+1];
+struct header {
+	long offset;
+	unsigned int count;
+};
+
+static mutex_t lock = DEFAULTMUTEX;
+
+static int cryptopen();
+static int writekey();
+
+void	_exit();
+
+int
+run_setkey(int p[2], const char *keyparam)
+{
+	(void) mutex_lock(&lock);
+	if (cryptopen(p) == -1) {
+		(void) mutex_unlock(&lock);
+		return (-1);
+	}
+	(void)  strncpy(key, keyparam, KSIZE);
+	if (*key == 0) {
+		(void) crypt_close_nolock(p);
+		(void) mutex_unlock(&lock);
+		return (0);
+	}
+	if (writekey(p, key) == -1) {
+		(void) mutex_unlock(&lock);
+		return (-1);
+	}
+	(void) mutex_unlock(&lock);
+	return (1);
+}
+
+static char cmd[] = "exec /usr/bin/crypt -p 2>/dev/null";
+static int
+cryptopen(int p[2])
+{
+	char c;
+
+	if (__p2open(cmd, p) < 0)
+		return (-1);
+	if (read(p[WRITER], &c, 1) != 1) { /* check that crypt is working on */
+					    /* other end */
+		(void)  crypt_close(p); /* remove defunct process */
+		return (-1);
+	}
+	return (1);
+}
+
+static int
+writekey(int p[2], char *keyarg)
+{
+	void (*pstat) ();
+	pstat = signal(SIGPIPE, SIG_IGN); /* don't want pipe errors to cause */
+					    /*  death */
+	if (write(p[READER], keyarg, KSIZE) != KSIZE) {
+		(void)  crypt_close(p); /* remove defunct process */
+		(void)  signal(SIGPIPE, pstat);
+		return (-1);
+	}
+	(void)  signal(SIGPIPE, pstat);
+	return (1);
+}
+
+
+int
+run_crypt(long offset, char *buffer, unsigned int count, int p[2])
+{
+	struct header header;
+	void (*pstat) ();
+
+	(void) mutex_lock(&lock);
+	header.count = count;
+	header.offset = offset;
+	pstat = signal(SIGPIPE, SIG_IGN);
+	if (write(p[READER], (char *)&header, sizeof (header))
+		!= sizeof (header)) {
+		(void) crypt_close_nolock(p);
+		(void) signal(SIGPIPE, pstat);
+		(void) mutex_unlock(&lock);
+		return (-1);
+	}
+	if (write(p[READER], buffer, count) < count) {
+		(void) crypt_close_nolock(p);
+		(void) signal(SIGPIPE, pstat);
+		(void) mutex_unlock(&lock);
+		return (-1);
+	}
+	if (read(p[WRITER], buffer,  count) < count) {
+		(void) crypt_close_nolock(p);
+		(void) signal(SIGPIPE, pstat);
+		(void) mutex_unlock(&lock);
+		return (-1);
+	}
+	(void) signal(SIGPIPE, pstat);
+	(void) mutex_unlock(&lock);
+	return (0);
+}
+
+int
+makekey(int b[2])
+{
+	int i;
+	long gorp;
+	char tempbuf[KSIZE], *a, *temp;
+
+	(void) mutex_lock(&lock);
+	a = key;
+	temp = tempbuf;
+	for (i = 0; i < KSIZE; i++)
+		temp[i] = *a++;
+	gorp = getuid() + getgid();
+
+	for (i = 0; i < 4; i++)
+		temp[i] ^= (char)((gorp>>(8*i))&0377);
+
+	if (cryptopen(b) == -1) {
+		(void) mutex_unlock(&lock);
+		return (-1);
+	}
+	if (writekey(b, temp) == -1) {
+		(void) mutex_unlock(&lock);
+		return (-1);
+	}
+	(void) mutex_unlock(&lock);
+	return (0);
+}
+
+int
+crypt_close_nolock(int p[2])
+{
+
+	if (p[0] == 0 && p[1] == 0 || p[0] < 0 || p[1] < 0) {
+		return (-1);
+	}
+
+	return (__p2close(p, NULL, SIGKILL));
+}
+
+int
+crypt_close(int p[2])
+{
+	(void) mutex_lock(&lock);
+	(void) crypt_close_nolock(p);
+	(void) mutex_unlock(&lock);
+	return (0);
+}