/* * 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 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" #define BSD_COMP #include #include #include #include #include #include #include #include /* for SC_WILDC */ #include #include #include #include #include #include #include #include #include /* * # include * # include * * * * # include */ #include #include #include #include "rex.h" #include pam_handle_t *pamh; #define NTTYDISC 2 /* New ttydiscipline: stolen from ttold.h */ /* * unix_login - hairy junk to simulate logins for Unix */ int Master, Slave; /* sides of the pty */ int Slave_is_closed_on_master_side; static char *slavename; extern char *ptsname(); int InputSocket, /* Network sockets */ OutputSocket; int Helper1, /* pids of the helpers */ Helper2; char UserName[256]; /* saves the user name for loging */ char HostName[256]; /* saves the host name for loging */ static int TtySlot; /* slot number in Utmpx */ /* * pseudo-xprts used to add pty fds to svc_pollfd[]. This allows the * polling for all i/o in one poll(). */ SVCXPRT uxprt[2]; #define INPUTSOCKET 0 /* InputSocket xprt */ #define MASTER 1 /* Master xprt */ extern int child; /* pid of the executed process */ extern int ChildDied; /* flag */ extern int HasHelper; /* flag */ extern void setproctitle(char *user, char *host); extern int Debug; extern void audit_rexd_fail(char *, char *, char *, uid_t, gid_t, char *, char **); #define bzero(s, n) memset((s), 0, (n)) #define bcopy(a, b, c) memcpy((b), (a), (c)) static void LogoutUser(void); /* * Check for user being able to run on this machine. * returns 0 if OK, TRUE if problem, error message in "error" * copies name of shell and home directory if user is valid. */ int ValidUser(host, uid, gid, error, shell, dir, rst) char *host; /* passed in */ uid_t uid; gid_t gid; char *error; /* filled in on return */ char *shell; /* filled in on return */ char *dir; /* filled in on return */ struct rex_start *rst; /* passed in */ { struct passwd *pw, *getpwuid(); int v; pw = getpwuid(uid); if (pw == NULL || pw->pw_name == NULL) { errprintf(error, "rexd: User id %d not valid\n", uid); audit_rexd_fail("user id is not valid", host, NULL, uid, gid, NULL, rst->rst_cmd); /* BSM */ return (1); } strncpy(UserName, pw->pw_name, sizeof (UserName) - 1); strncpy(HostName, host, sizeof (HostName) - 1); strcpy(shell, pw->pw_shell); strcpy(dir, pw->pw_dir); setproctitle(pw->pw_name, host); if (pam_start("rexd", pw->pw_name, NULL, &pamh) != PAM_SUCCESS || pam_set_item(pamh, PAM_RHOST, host) != PAM_SUCCESS) { audit_rexd_fail("user id is not valid", host, pw->pw_name, uid, gid, shell, rst->rst_cmd); /* BSM */ errprintf(error, "rexd: User id %d not valid\n", uid); if (pamh) { pam_end(pamh, PAM_ABORT); pamh = NULL; } return (1); } if ((v = pam_acct_mgmt(pamh, 0)) != PAM_SUCCESS) { switch (v) { case PAM_NEW_AUTHTOK_REQD: errprintf(error, "rexd: User id %d Password Expired\n", uid); break; case PAM_PERM_DENIED: errprintf(error, "rexd: User id %d Account Expired\n", uid); break; case PAM_AUTHTOK_EXPIRED: errprintf(error, "rexd: User id %d Password Expired\n", uid); break; default: errprintf(error, "rexd: User id %d not valid\n", uid); break; } pam_end(pamh, PAM_ABORT); pamh = NULL; audit_rexd_fail("user account expired", host, pw->pw_name, uid, gid, shell, rst->rst_cmd); /* BSM */ return (1); } return (0); } /* * Add an audit record with argv that was pre-set, plus the given string */ /* * Allocate a pseudo-terminal * sets the global variables Master and Slave. * returns 1 on error, 0 if OK */ int AllocatePty(socket0, socket1) int socket0, socket1; { int on = 1; sigset(SIGHUP, SIG_IGN); sigset(SIGTTOU, SIG_IGN); sigset(SIGTTIN, SIG_IGN); if ((Master = open("/dev/ptmx", O_RDWR)) == -1) { if (Debug) printf("open-ptmx-failure\n"); perror("AloocatePtyMaster fails"); return (1); /* error could not open /dev/ptmx */ } if (Debug) printf("open-ptmx success Master =%d\n", Master); if (Debug) printf("Before grantpt...Master=%d\n", Master); if (grantpt(Master) == -1) { perror("could not grant slave pty"); exit(1); } if (unlockpt(Master) == -1) { perror("could not unlock slave pty"); exit(1); } if ((slavename = ptsname(Master)) == NULL) { perror("could not enable slave pty"); exit(1); } if ((Slave = open(slavename, O_RDWR)) == -1) { perror("could not open slave pty"); exit(1); } if (ioctl(Slave, I_PUSH, "ptem") == -1) { perror("ioctl I_PUSH ptem"); exit(1); } if (ioctl(Slave, I_PUSH, "ldterm") == -1) { perror("ioctl I_PUSH ldterm"); exit(1); } if (ioctl(Slave, I_PUSH, "ttcompat") == -1) { perror("ioctl I_PUSH ttcompat"); exit(1); } Slave_is_closed_on_master_side = FALSE; setsid(); /* get rid of controlling terminal */ /* LoginUser(); */ InputSocket = socket0; OutputSocket = socket1; ioctl(Master, FIONBIO, &on); uxprt[INPUTSOCKET].xp_fd = InputSocket; xprt_register(&uxprt[INPUTSOCKET]); uxprt[MASTER].xp_fd = Master; xprt_register(&uxprt[MASTER]); return (0); } void OpenPtySlave() { close(Slave); Slave = open(slavename, O_RDWR); if (Slave < 0) { perror(slavename); exit(1); } } /* * Special processing for interactive operation. * Given pointers to three standard file descriptors, * which get set to point to the pty. */ void DoHelper(pfd0, pfd1, pfd2) int *pfd0, *pfd1, *pfd2; { int pgrp; sigset(SIGINT, SIG_IGN); close(Master); close(InputSocket); close(OutputSocket); *pfd0 = Slave; *pfd1 = Slave; *pfd2 = Slave; } /* * destroy the helpers when the executing process dies */ void KillHelper(int grp) { if (Debug) printf("Enter KillHelper\n"); close(Master); xprt_unregister(&uxprt[MASTER]); close(InputSocket); xprt_unregister(&uxprt[INPUTSOCKET]); close(OutputSocket); LogoutUser(); if (grp) kill((-grp), SIGKILL); } /* * edit the Unix traditional data files that tell who is logged * into "the system" */ unsigned char utid[] = {'o', 'n', SC_WILDC, SC_WILDC}; void LoginUser(void) { char *user; char *rhost; /* the next 4 variables are needed for utmpx mgmt */ int tmplen; struct utmpx *u = NULL; struct utmpx set_utmp; char *ttyntail; /* We're pretty drastic here, exiting if an error is detected */ if (pam_set_item(pamh, PAM_TTY, slavename) != PAM_SUCCESS || pam_get_item(pamh, PAM_USER, (void **) &user) != PAM_SUCCESS || pam_get_item(pamh, PAM_RHOST, (void **) &rhost) != PAM_SUCCESS || pam_open_session(pamh, 0) != PAM_SUCCESS) { /* * XXX should print something but for now we exit */ exit(1); } (void) memset((void *)&set_utmp, 0, sizeof (set_utmp)); (void) time(&set_utmp.ut_tv.tv_sec); set_utmp.ut_pid = getpid(); if (rhost != NULL && rhost[0] != '\0') { (void) strcpy(set_utmp.ut_host, rhost); tmplen = strlen(rhost) + 1; if (tmplen < sizeof (set_utmp.ut_host)) set_utmp.ut_syslen = tmplen; else set_utmp.ut_syslen = sizeof (set_utmp.ut_host); } else { (void) memset(set_utmp.ut_host, 0, sizeof (set_utmp.ut_host)); set_utmp.ut_syslen = 0; } (void) strcpy(set_utmp.ut_user, user); /* * Copy in the name of the tty minus the "/dev/" if a /dev/ is * in the path name. */ ttyntail = slavename; if (strstr(ttyntail, "/dev/") != 0) ttyntail = ttyntail + strlen("/dev/"); (void) strcpy(set_utmp.ut_line, ttyntail); set_utmp.ut_type = USER_PROCESS; if (utid != NULL) (void) memcpy(set_utmp.ut_id, utid, sizeof (set_utmp.ut_id)); /* * Go through each entry one by one, looking only at INIT, * LOGIN or USER Processes. Use the entry found if flags == 0 * and the line name matches, or if the process ID matches if * the UPDATE_ENTRY flag is set. The UPDATE_ENTRY flag is mainly * for login which normally only wants to update an entry if * the pid fields matches. */ if (u == (struct utmpx *)NULL) { (void) makeutx(&set_utmp); } else updwtmpx(WTMPX_FILE, &set_utmp); } /* * edit the Unix traditional data files that tell who is logged * into "the system". */ static void LogoutUser(void) { struct utmpx *up; struct utmpx ut; int pid; char user[sizeof (ut.ut_user) + 1]; char ttyn[sizeof (ut.ut_line) + 1]; char rhost[sizeof (ut.ut_host) + 1]; sighold(SIGCHLD); /* no disruption during cleanup */ if (pamh) { pam_end(pamh, PAM_SUCCESS); pamh = NULL; } /* BEGIN RESET UTMP */ pid = child; setutxent(); while (up = getutxent()) { if (up->ut_pid == pid) { if (up->ut_type == DEAD_PROCESS) { /* * Cleaned up elsewhere. */ break; } strncpy(user, up->ut_user, sizeof (up->ut_user)); user[sizeof (up->ut_user)] = '\0'; strncpy(ttyn, up->ut_line, sizeof (up->ut_line)); ttyn[sizeof (up->ut_line)] = '\0'; strncpy(rhost, up->ut_host, sizeof (up->ut_host)); rhost[sizeof (up->ut_host)] = '\0'; if ((pam_start("rexd", user, NULL, &pamh)) == PAM_SUCCESS) { (void) pam_set_item(pamh, PAM_TTY, ttyn); (void) pam_set_item(pamh, PAM_RHOST, rhost); (void) pam_close_session(pamh, 0); (void) pam_end(pamh, PAM_SUCCESS); pamh = NULL; } up->ut_type = DEAD_PROCESS; up->ut_exit.e_termination = WTERMSIG(0); up->ut_exit.e_exit = WEXITSTATUS(0); (void) time(&up->ut_tv.tv_sec); if (modutx(up) == NULL) { /* * Since modutx failed we'll * write out the new entry * ourselves. */ (void) pututxline(up); updwtmpx("wtmpx", up); } break; } } endutxent(); /* END RESET UTMP */ sigrelse(SIGCHLD); } /* * set the pty modes to the given values */ void SetPtyMode(mode) struct rex_ttymode *mode; { struct sgttyb svr4_sgttyb_var; int ldisc = NTTYDISC; if (Debug) printf("Enter SetPtyMode\n"); if (Debug) printf("SetPtyMode:opened slave\n"); ioctl(Slave, TIOCSETD, &ldisc); if (Debug) printf("SetPtyMode:Slave TIOCSETD done\n"); /* * Copy from over-the-net(bsd) to SVR4 format */ svr4_sgttyb_var.sg_ispeed = mode->basic.sg_ispeed; svr4_sgttyb_var.sg_ospeed = mode->basic.sg_ospeed; svr4_sgttyb_var.sg_erase = mode->basic.sg_erase; svr4_sgttyb_var.sg_kill = mode->basic.sg_kill; svr4_sgttyb_var.sg_flags = (int)mode->basic.sg_flags; /* * Clear any possible sign extension caused by (int) * typecast */ svr4_sgttyb_var.sg_flags &= 0xFFFF; ioctl(Slave, TIOCSETN, &svr4_sgttyb_var); if (Debug) printf("SetPtyMode:Slave TIOCSETN done\n"); ioctl(Slave, TIOCSETC, &mode->more); if (Debug) printf("SetPtyMode:Slave TIOCSETC done\n"); ioctl(Slave, TIOCSLTC, &mode->yetmore); if (Debug) printf("SetPtyMode:Slave TIOCSLTC done\n"); ioctl(Slave, TIOCLSET, &mode->andmore); if (Debug) printf("SetPtyMode:Slave TIOCSET done\n"); /* Opened in AllocPty for parent, still open in child */ if (Slave_is_closed_on_master_side == FALSE) { close(Slave); Slave_is_closed_on_master_side = TRUE; } } /* * set the pty window size to the given value */ void SetPtySize(struct rex_ttysize *sizep) { struct winsize newsize; /* if size has changed, this ioctl changes it */ /* *and* sends SIGWINCH to process group */ newsize.ws_row = (unsigned short) sizep->ts_lines; newsize.ws_col = (unsigned short) sizep->ts_cols; (void) ioctl(Master, TIOCSWINSZ, &newsize); if (Slave_is_closed_on_master_side == FALSE) { close(Slave); Slave_is_closed_on_master_side = TRUE; } } /* * send the given signal to the group controlling the terminal */ void SendSignal(int sig) { pid_t pgrp; pgrp = getpgid(child); if (pgrp != (pid_t)-1) (void) kill((-pgrp), sig); } /* * called when the main select loop detects that we might want to * read something. */ void HelperRead(pollfd_t *fdp, int nfds, int *pollretval) { char buf[128]; int retval; extern int errno; int mask; int master = -1; int inputsocket = -1; /* * fdp pollset may be compressed. Search for Master and * InputSocket fds. */ int i; for (i = 0; i < nfds; i++) { if (fdp[i].fd == Master && fdp[i].revents != 0) master = i; if (fdp[i].fd == InputSocket && fdp[i].revents != 0) inputsocket = i; } /* mask = sigsetmask (sigmask (SIGCHLD)); */ mask = sighold(SIGCHLD); retval = 0; if (master != -1) { if (!(fdp[master].revents & (POLLERR | POLLHUP | POLLNVAL))) { retval = read(Master, buf, sizeof (buf)); if (retval > 0) { (void) write(OutputSocket, buf, retval); } else { if (errno != EINTR && errno != EIO && errno != EWOULDBLOCK) perror("pty read"); /* 1 => further sends disallowed */ shutdown(OutputSocket, 1); xprt_unregister(&uxprt[MASTER]); } } /* clear this event for svc_getreq_poll */ fdp[master].revents = 0; *pollretval = *pollretval - 1; if (retval <= 0 && ChildDied) { KillHelper(child); HasHelper = 0; if (inputsocket != -1) { fdp[inputsocket].revents = 0; *pollretval = *pollretval - 1; } goto done; } } if (inputsocket != -1) { if (!(fdp[inputsocket].revents & (POLLERR | POLLHUP | POLLNVAL))) { retval = read(InputSocket, buf, sizeof (buf)); if (retval > 0) { (void) write(Master, buf, retval); } else { if (errno != EINTR && errno != EWOULDBLOCK) perror("socket read"); xprt_unregister(&uxprt[INPUTSOCKET]); } } /* clear this event for svc_getreq_poll */ fdp[inputsocket].revents = 0; *pollretval = *pollretval - 1; } done: /* sigsetmask (mask); */ sigrelse(SIGCHLD); }