OpenSolaris_b135/cmd/bnu/in.uucpd.c
/*
* 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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* 4.2BSD, 2.9BSD, or ATTSVR4 TCP/IP server for uucico
* uucico's TCP channel causes this server to be run at the remote end.
*/
#include "uucp.h"
#include <netdb.h>
#ifdef BSD2_9
#include <sys/localopts.h>
#include <sys/file.h>
#endif /* BSD2_9 */
#include <signal.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/wait.h>
#ifdef ATTSVTTY
#include <sys/termio.h>
#else
#include <sys/ioctl.h>
#endif
#include <pwd.h>
#ifdef ATTSVR4
#include <shadow.h>
#endif
#include <lastlog.h>
#include <security/pam_appl.h>
static int uucp_conv();
struct pam_conv conv = {uucp_conv, NULL };
pam_handle_t *pamh;
#if !defined(BSD4_2) && !defined(BSD2_9) && !defined(ATTSVR4)
--- You must have either BSD4_2, BSD2_9, or ATTSVR4 defined for this to work
#endif /* !BSD4_2 && !BSD2_9 */
#if defined(BSD4_2) && defined(BSD2_9)
--- You may not have both BSD4_2 and BSD2_9 defined for this to work
#endif /* check for stupidity */
char lastlog[] = "/var/adm/lastlog";
struct passwd nouser = {
"", "nope", (uid_t)-1, (gid_t)-1, "", "", "", "", "" };
#ifdef ATTSVR4
struct spwd noupass = { "", "nope" };
#endif
struct sockaddr_in hisctladdr;
socklen_t hisaddrlen = (socklen_t)sizeof (hisctladdr);
struct sockaddr_in myctladdr;
int nolog; /* don't log in utmp or wtmp */
char Username[64];
char Loginname[64];
char *nenv[] = {
Username,
Loginname,
NULL,
};
extern char **environ;
static void doit(struct sockaddr_in *);
static void dologout(void);
int
main(argc, argv)
int argc;
char **argv;
{
#ifndef BSDINETD
int s, tcp_socket;
struct servent *sp;
#endif /* !BSDINETD */
extern int errno;
if (argc > 1 && strcmp(argv[1], "-n") == 0)
nolog = 1;
environ = nenv;
#ifdef BSDINETD
close(1); close(2);
dup(0); dup(0);
hisaddrlen = (socklen_t)sizeof (hisctladdr);
if (getpeername(0, (struct sockaddr *)&hisctladdr, &hisaddrlen) < 0) {
fprintf(stderr, "%s: ", argv[0]);
perror("getpeername");
_exit(1);
}
if (fork() == 0)
doit(&hisctladdr);
dologout();
exit(1);
#else /* !BSDINETD */
sp = getservbyname("uucp", "tcp");
if (sp == NULL) {
perror("uucpd: getservbyname");
exit(1);
}
if (fork())
exit(0);
#ifdef ATTSVR4
setsid();
#else
if ((s = open("/dev/tty", 2)) >= 0) {
ioctl(s, TIOCNOTTY, (char *)0);
close(s);
}
#endif
#ifdef ATTSVR4
memset((void *)&myctladdr, 0, sizeof (myctladdr));
#else
bzero((char *)&myctladdr, sizeof (myctladdr));
#endif
myctladdr.sin_family = AF_INET;
myctladdr.sin_port = sp->s_port;
#if defined(BSD4_2) || defined(ATTSVR4)
tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
if (tcp_socket < 0) {
perror("uucpd: socket");
exit(1);
}
if (bind(tcp_socket, (char *)&myctladdr, sizeof (myctladdr)) < 0) {
perror("uucpd: bind");
exit(1);
}
listen(tcp_socket, 3); /* at most 3 simultaneuos uucp connections */
signal(SIGCHLD, dologout);
for (;;) {
s = accept(tcp_socket, &hisctladdr, &hisaddrlen);
if (s < 0) {
if (errno == EINTR)
continue;
perror("uucpd: accept");
exit(1);
}
if (fork() == 0) {
close(0); close(1); close(2);
dup(s); dup(s); dup(s);
close(tcp_socket); close(s);
doit(&hisctladdr);
exit(1);
}
close(s);
}
#endif /* BSD4_2 */
#ifdef BSD2_9
for (;;) {
signal(SIGCHLD, dologout);
s = socket(SOCK_STREAM, 0, &myctladdr,
SO_ACCEPTCONN|SO_KEEPALIVE);
if (s < 0) {
perror("uucpd: socket");
exit(1);
}
if (accept(s, &hisctladdr) < 0) {
if (errno == EINTR) {
close(s);
continue;
}
perror("uucpd: accept");
exit(1);
}
if (fork() == 0) {
close(0); close(1); close(2);
dup(s); dup(s); dup(s);
close(s);
doit(&hisctladdr);
exit(1);
}
}
#endif /* BSD2_9 */
#endif /* !BSDINETD */
/* NOTREACHED */
}
static void
doit(sinp)
struct sockaddr_in *sinp;
{
char user[64], passwd[64];
struct passwd *pw, *getpwnam();
int error;
alarm(60);
printf("login: "); fflush(stdout);
if (readline(user, sizeof (user)) < 0) {
fprintf(stderr, "user read\n");
return;
}
/*
* Call pam_start to initiate a PAM authentication operation
*/
if ((pam_start("uucp", user, &conv, &pamh)) != PAM_SUCCESS)
return;
if ((pam_set_item(pamh, PAM_TTY, ttyname(0))) != PAM_SUCCESS)
return;
if (pam_authenticate(pamh, PAM_SILENT) != PAM_SUCCESS) {
/* force a delay if passwd bad */
sleep(4);
fprintf(stderr, "Login incorrect.");
pam_end(pamh, PAM_ABORT);
return;
}
if ((error = pam_acct_mgmt(pamh, PAM_SILENT)) != PAM_SUCCESS) {
switch (error) {
case PAM_NEW_AUTHTOK_REQD:
fprintf(stderr, "Password Expired.");
break;
case PAM_PERM_DENIED:
fprintf(stderr, "Account Expired.");
break;
case PAM_AUTHTOK_EXPIRED:
fprintf(stderr, "Password Expired.");
break;
default:
fprintf(stderr, "Login incorrect.");
break;
}
pam_end(pamh, PAM_ABORT);
return;
}
if ((pw = getpwnam(user)) == NULL || strcmp(pw->pw_shell, UUCICO)) {
/* force a delay if user bad */
sleep(4);
fprintf(stderr, "Login incorrect.");
pam_end(pamh, PAM_USER_UNKNOWN);
return;
}
alarm(0);
sprintf(Username, "USER=%s", user);
sprintf(Loginname, "LOGNAME=%s", user);
if (!nolog)
if (dologin(pw, sinp)) {
pam_end(pamh, PAM_ABORT);
_exit(1);
}
/* set the real (and effective) GID */
if (setgid(pw->pw_gid) == -1) {
fprintf(stderr, "Login incorrect.");
pam_end(pamh, PAM_PERM_DENIED);
return;
}
/*
* Initialize the supplementary group access list.
*/
if (initgroups(user, pw->pw_gid) == -1) {
fprintf(stderr, "Login incorrect.");
pam_end(pamh, PAM_PERM_DENIED);
return;
}
if (pam_setcred(pamh, PAM_ESTABLISH_CRED) != PAM_SUCCESS) {
fprintf(stderr, "Login incorrect.");
pam_end(pamh, PAM_CRED_INSUFFICIENT);
return;
}
/* set the real (and effective) UID */
if (setuid(pw->pw_uid) == -1) {
fprintf(stderr, "Login incorrect.");
pam_end(pamh, PAM_CRED_ERR);
return;
}
chdir(pw->pw_dir);
pam_end(pamh, PAM_SUCCESS);
#if defined(BSD4_2) || defined(ATTSVR4)
execl(UUCICO, "uucico", "-u", user, (char *)0);
#endif /* BSD4_2 */
#ifdef BSD2_9
sprintf(passwd, "-h%s", inet_ntoa(sinp->sin_addr));
execl(UUCICO, "uucico", passwd, (char *)0);
#endif /* BSD2_9 */
perror("uucico server: execl");
}
int
readline(p, n)
char *p;
int n;
{
char c;
while (n-- > 0) {
if (read(0, &c, 1) <= 0)
return (-1);
c &= 0177;
if (c == '\n' || c == '\r') {
*p = '\0';
return (0);
}
*p++ = c;
}
return (-1);
}
#ifdef ATTSVR4
#include <sac.h> /* for SC_WILDC */
#include <utmpx.h>
#else /* !ATTSVR4 */
#include <utmp.h>
#endif /* !ATTSVR4 */
#if defined(BSD4_2) || defined(ATTSVR4)
#include <fcntl.h>
#endif /* BSD4_2 */
#ifdef BSD2_9
#define O_APPEND 0 /* kludge */
#define wait3(a, b, c) wait2(a, b)
#endif /* BSD2_9 */
#define SCPYN(a, b) strncpy(a, b, sizeof (a))
#ifdef ATTSVR4
struct utmpx utmp;
#else /* !ATTSVR4 */
struct utmp utmp;
#endif /* !ATTSVR4 */
static void
dologout(void)
{
#ifdef ATTSVR4
int status;
#else /* !ATTSVR4 */
union wait status;
#endif /* !ATSVR4 */
int pid, wtmp;
/* the following 2 variables are needed for utmp mgmt */
struct utmpx ut;
#ifdef BSDINETD
while ((pid = wait(&status)) > 0) {
#else /* !BSDINETD */
while ((pid = wait3(&status, WNOHANG, 0)) > 0) {
#endif /* !BSDINETD */
if (nolog)
continue;
#ifdef ATTSVR4
/* clear out any residue from utmpx buffer */
(void) memset((char *)&ut, 0, sizeof (ut));
SCPYN(utmp.ut_user, "");
ut.ut_id[0] = 'u';
ut.ut_id[1] = 'u';
ut.ut_id[2] = SC_WILDC;
ut.ut_id[3] = SC_WILDC;
sprintf(ut.ut_line, "uucp%.4d", pid);
ut.ut_pid = getpid();
ut.ut_type = DEAD_PROCESS;
ut.ut_exit.e_termination = status & 0xFF;
ut.ut_exit.e_exit = WEXITSTATUS(status);
SCPYN(ut.ut_host, "");
ut.ut_syslen = 1;
(void) gettimeofday(&ut.ut_tv, NULL);
/*
* XXX: UUCPD does not do any pam session management.
* There is no way for the parent process to close
* the pam session after a child has exited.
*/
updwtmpx(WTMPX_FILE, &ut);
#else /* !ATTSVR4 */
wtmp = open("/usr/adm/wtmp", O_WRONLY|O_APPEND);
if (wtmp >= 0) {
sprintf(utmp.ut_line, "uucp%.4d", pid);
SCPYN(utmp.ut_name, "");
SCPYN(utmp.ut_host, "");
(void) time(&utmp.ut_time);
#ifdef BSD2_9
(void) lseek(wtmp, 0L, 2);
#endif /* BSD2_9 */
(void) write(wtmp, (char *)&utmp, sizeof (utmp));
(void) close(wtmp);
}
#endif /* !ATTSVR4 */
}
}
/*
* Record login in wtmp file.
*/
int
dologin(pw, sin)
struct passwd *pw;
struct sockaddr_in *sin;
{
char line[32];
char remotehost[32];
int wtmp;
struct hostent *hp = gethostbyaddr((const char *)&sin->sin_addr,
sizeof (struct in_addr), AF_INET);
struct utmpx ut;
if (hp) {
strncpy(remotehost, hp->h_name, sizeof (remotehost));
endhostent();
} else
strncpy(remotehost, (char *)inet_ntoa(sin->sin_addr),
sizeof (remotehost));
#ifdef ATTSVR4
/* clear wtmpx entry */
(void) memset((void *)&ut, 0, sizeof (ut));
SCPYN(ut.ut_user, pw->pw_name);
ut.ut_id[0] = 'u';
ut.ut_id[1] = 'u';
ut.ut_id[2] = SC_WILDC;
ut.ut_id[3] = SC_WILDC;
/* hack, but must be unique and no tty line */
sprintf(line, "uucp%.4d", getpid());
SCPYN(ut.ut_line, line);
ut.ut_pid = getpid();
ut.ut_type = USER_PROCESS;
ut.ut_exit.e_termination = 0;
ut.ut_exit.e_exit = 0;
SCPYN(ut.ut_host, remotehost);
ut.ut_syslen = strlen(remotehost) + 1;
(void) gettimeofday(&ut.ut_tv, 0);
updwtmpx(WTMPX_FILE, &ut);
/*
* XXX:
* We no longer do session management in uucpd because
* there is no way to do the "pam_close_session()".
*
* Processes like "init" can do a pam_close_session()
* because they can use the utmp entry to retrieve
* the proper username, ttyname, etc. --
* uucpd only writes to the wtmp file.
*
* ftpd (which also only writes to the wtmp file)
* can do a pam_close_session() because it doesn't fork().
*
* if (pam_set_item(pamh, PAM_RHOST, remotehost) != PAM_SUCCESS)
* return (1);
* if (pam_set_item(pamh, PAM_TTY, line) != PAM_SUCCESS)
* return (1);
* if (pam_open_session(pamh, 0) != PAM_SUCCESS) {
* return (1);
* }
*/
#else /* !ATTSVR4 */
wtmp = open("/usr/adm/wtmp", O_WRONLY|O_APPEND);
if (wtmp >= 0) {
/* hack, but must be unique and no tty line */
sprintf(line, "uucp%.4d", getpid());
SCPYN(utmp.ut_line, line);
SCPYN(utmp.ut_name, pw->pw_name);
SCPYN(utmp.ut_host, remotehost);
time(&utmp.ut_time);
#ifdef BSD2_9
(void) lseek(wtmp, 0L, 2);
#endif /* BSD2_9 */
(void) write(wtmp, (char *)&utmp, sizeof (utmp));
(void) close(wtmp);
}
#endif /* !ATTSVR4 */
return (0);
}
/*
* uucp_conv - This is the conv (conversation) function called from
* a PAM authentication module to print error messages
* or garner information from the user.
*/
static int
uucp_conv(num_msg, msg, response, appdata_ptr)
int num_msg;
struct pam_message **msg;
struct pam_response **response;
void *appdata_ptr;
{
struct pam_message *m;
struct pam_response *r;
char *temp;
static char passwd[64];
int k, i;
if (num_msg <= 0)
return (PAM_CONV_ERR);
*response = (struct pam_response *)calloc(num_msg,
sizeof (struct pam_response));
if (*response == NULL)
return (PAM_BUF_ERR);
k = num_msg;
m = *msg;
r = *response;
while (k--) {
switch (m->msg_style) {
case PAM_PROMPT_ECHO_OFF:
/*
* we do this instead of using passed in message
* to prevent possible breakage of uucp protocol.
*/
printf("Password: "); fflush(stdout);
if (readline(passwd, sizeof (passwd)) < 0) {
fprintf(stderr, "passwd read\n");
return (PAM_SUCCESS);
}
temp = passwd;
if (temp != NULL) {
r->resp = strdup(temp);
if (r->resp == NULL) {
/* free responses */
r = *response;
for (i = 0; i < num_msg; i++, r++) {
if (r->resp)
free(r->resp);
}
free(*response);
*response = NULL;
return (PAM_BUF_ERR);
}
}
m++;
r++;
break;
case PAM_PROMPT_ECHO_ON:
if (m->msg != NULL) {
fputs(m->msg, stdout);
fflush(stdout);
}
r->resp = (char *)malloc(PAM_MAX_RESP_SIZE);
if (r->resp == NULL) {
/* free the response */
r = *response;
for (i = 0; i < num_msg; i++, r++) {
if (r->resp)
free(r->resp);
}
free(*response);
*response = NULL;
return (PAM_BUF_ERR);
}
(void) fgets(r->resp, PAM_MAX_RESP_SIZE, stdin);
m++;
r++;
break;
case PAM_ERROR_MSG:
if (m->msg != NULL) {
fputs(m->msg, stderr);
fputs("\n", stderr);
}
m++;
r++;
break;
case PAM_TEXT_INFO:
if (m->msg != NULL) {
fputs(m->msg, stdout);
fputs("\n", stdout);
}
m++;
r++;
break;
default:
break;
}
}
return (PAM_SUCCESS);
}