17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 509295472Sgww * Common Development and Distribution License (the "License"). 609295472Sgww * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*634e26ecSCasper H.S. Dik * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 277c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* Copyright (c) 1987, 1988 Microsoft Corporation */ 307c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate /* 337c478bd9Sstevel@tonic-gate * su [-] [name [arg ...]] change userid, `-' changes environment. 347c478bd9Sstevel@tonic-gate * If SULOG is defined, all attempts to su to another user are 357c478bd9Sstevel@tonic-gate * logged there. 367c478bd9Sstevel@tonic-gate * If CONSOLE is defined, all successful attempts to su to uid 0 377c478bd9Sstevel@tonic-gate * are also logged there. 387c478bd9Sstevel@tonic-gate * 397c478bd9Sstevel@tonic-gate * If su cannot create, open, or write entries into SULOG, 407c478bd9Sstevel@tonic-gate * (or on the CONSOLE, if defined), the entry will not 417c478bd9Sstevel@tonic-gate * be logged -- thus losing a record of the su's attempted 427c478bd9Sstevel@tonic-gate * during this period. 437c478bd9Sstevel@tonic-gate */ 447c478bd9Sstevel@tonic-gate 457c478bd9Sstevel@tonic-gate #include <stdio.h> 467c478bd9Sstevel@tonic-gate #include <sys/types.h> 477c478bd9Sstevel@tonic-gate #include <sys/stat.h> 487c478bd9Sstevel@tonic-gate #include <sys/param.h> 497c478bd9Sstevel@tonic-gate #include <unistd.h> 507c478bd9Sstevel@tonic-gate #include <stdlib.h> 517c478bd9Sstevel@tonic-gate #include <crypt.h> 527c478bd9Sstevel@tonic-gate #include <pwd.h> 537c478bd9Sstevel@tonic-gate #include <shadow.h> 547c478bd9Sstevel@tonic-gate #include <time.h> 557c478bd9Sstevel@tonic-gate #include <signal.h> 567c478bd9Sstevel@tonic-gate #include <fcntl.h> 577c478bd9Sstevel@tonic-gate #include <string.h> 587c478bd9Sstevel@tonic-gate #include <locale.h> 597c478bd9Sstevel@tonic-gate #include <syslog.h> 607c478bd9Sstevel@tonic-gate #include <sys/utsname.h> 6109295472Sgww #include <sys/wait.h> 627c478bd9Sstevel@tonic-gate #include <grp.h> 637c478bd9Sstevel@tonic-gate #include <deflt.h> 647c478bd9Sstevel@tonic-gate #include <limits.h> 657c478bd9Sstevel@tonic-gate #include <errno.h> 667c478bd9Sstevel@tonic-gate #include <stdarg.h> 6709295472Sgww #include <user_attr.h> 6809295472Sgww #include <priv.h> 697c478bd9Sstevel@tonic-gate 705435d801Sgww #include <bsm/adt.h> 715435d801Sgww #include <bsm/adt_event.h> 725435d801Sgww 737c478bd9Sstevel@tonic-gate #include <security/pam_appl.h> 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate #define PATH "/usr/bin:" /* path for users other than root */ 767c478bd9Sstevel@tonic-gate #define SUPATH "/usr/sbin:/usr/bin" /* path for root */ 777c478bd9Sstevel@tonic-gate #define SUPRMT "PS1=# " /* primary prompt for root */ 787c478bd9Sstevel@tonic-gate #define ELIM 128 797c478bd9Sstevel@tonic-gate #define ROOT 0 807c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 817c478bd9Sstevel@tonic-gate #define EMBEDDED_NAME "embedded_su" 825435d801Sgww #define DEF_ATTEMPTS 3 /* attempts to change password */ 837c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 847c478bd9Sstevel@tonic-gate 855435d801Sgww #define PW_FALSE 1 /* no password change */ 865435d801Sgww #define PW_TRUE 2 /* successful password change */ 875435d801Sgww #define PW_FAILED 3 /* failed password change */ 885435d801Sgww 897c478bd9Sstevel@tonic-gate /* 907c478bd9Sstevel@tonic-gate * Intervals to sleep after failed su 917c478bd9Sstevel@tonic-gate */ 927c478bd9Sstevel@tonic-gate #ifndef SLEEPTIME 937c478bd9Sstevel@tonic-gate #define SLEEPTIME 4 947c478bd9Sstevel@tonic-gate #endif 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate #define DEFAULT_LOGIN "/etc/default/login" 977c478bd9Sstevel@tonic-gate #define DEFFILE "/etc/default/su" 987c478bd9Sstevel@tonic-gate 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate char *Sulog, *Console; 1017c478bd9Sstevel@tonic-gate char *Path, *Supath; 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate /* 1047c478bd9Sstevel@tonic-gate * Locale variables to be propagated to "su -" environment 1057c478bd9Sstevel@tonic-gate */ 1067c478bd9Sstevel@tonic-gate static char *initvar; 1077c478bd9Sstevel@tonic-gate static char *initenv[] = { 1087c478bd9Sstevel@tonic-gate "TZ", "LANG", "LC_CTYPE", 1097c478bd9Sstevel@tonic-gate "LC_NUMERIC", "LC_TIME", "LC_COLLATE", 1107c478bd9Sstevel@tonic-gate "LC_MONETARY", "LC_MESSAGES", "LC_ALL", 0}; 1117c478bd9Sstevel@tonic-gate static char mail[30] = { "MAIL=/var/mail/" }; 1127c478bd9Sstevel@tonic-gate 1137c478bd9Sstevel@tonic-gate static void envalt(void); 1145435d801Sgww static void log(char *, char *, int); 1155435d801Sgww static void to(int); 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate enum messagemode { USAGE, ERR, WARN }; 1185435d801Sgww static void message(enum messagemode, char *, ...); 1197c478bd9Sstevel@tonic-gate 1205435d801Sgww static char *alloc_vsprintf(const char *, va_list); 1215435d801Sgww static char *tail(char *); 1227c478bd9Sstevel@tonic-gate 1235435d801Sgww static void audit_success(int, struct passwd *); 12409295472Sgww static void audit_logout(adt_session_data_t *, au_event_t); 12509295472Sgww static void audit_failure(int, struct passwd *, char *, int); 1267c478bd9Sstevel@tonic-gate 1277c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 1285435d801Sgww static void validate(char *, int *); 1295435d801Sgww static int legalenvvar(char *); 1307c478bd9Sstevel@tonic-gate static int su_conv(int, struct pam_message **, struct pam_response **, void *); 1317c478bd9Sstevel@tonic-gate static int emb_su_conv(int, struct pam_message **, struct pam_response **, 1327c478bd9Sstevel@tonic-gate void *); 1335435d801Sgww static void freeresponse(int, struct pam_response **response); 1347c478bd9Sstevel@tonic-gate static struct pam_conv pam_conv = {su_conv, NULL}; 1357c478bd9Sstevel@tonic-gate static struct pam_conv emb_pam_conv = {emb_su_conv, NULL}; 1365435d801Sgww static void quotemsg(char *, ...); 1377c478bd9Sstevel@tonic-gate static void readinitblock(void); 1385435d801Sgww #else /* !DYNAMIC_SU */ 1395435d801Sgww static void update_audit(struct passwd *pwd); 1407c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 1417c478bd9Sstevel@tonic-gate 1425435d801Sgww static pam_handle_t *pamh = NULL; /* Authentication handle */ 1437c478bd9Sstevel@tonic-gate struct passwd pwd; 1447c478bd9Sstevel@tonic-gate char pwdbuf[1024]; /* buffer for getpwnam_r() */ 1457c478bd9Sstevel@tonic-gate char shell[] = "/usr/bin/sh"; /* default shell */ 1467c478bd9Sstevel@tonic-gate char safe_shell[] = "/sbin/sh"; /* "fallback" shell */ 1477c478bd9Sstevel@tonic-gate char su[PATH_MAX] = "su"; /* arg0 for exec of shprog */ 1487c478bd9Sstevel@tonic-gate char homedir[PATH_MAX] = "HOME="; 1497c478bd9Sstevel@tonic-gate char logname[20] = "LOGNAME="; 1507c478bd9Sstevel@tonic-gate char *suprmt = SUPRMT; 1517c478bd9Sstevel@tonic-gate char termtyp[PATH_MAX] = "TERM="; 1527c478bd9Sstevel@tonic-gate char *term; 1537c478bd9Sstevel@tonic-gate char shelltyp[PATH_MAX] = "SHELL="; 1547c478bd9Sstevel@tonic-gate char *hz; 1557c478bd9Sstevel@tonic-gate char tznam[PATH_MAX]; 1567c478bd9Sstevel@tonic-gate char hzname[10] = "HZ="; 1577c478bd9Sstevel@tonic-gate char path[PATH_MAX] = "PATH="; 1587c478bd9Sstevel@tonic-gate char supath[PATH_MAX] = "PATH="; 1597c478bd9Sstevel@tonic-gate char *envinit[ELIM]; 1607c478bd9Sstevel@tonic-gate extern char **environ; 1617c478bd9Sstevel@tonic-gate char *ttyn; 1627c478bd9Sstevel@tonic-gate char *username; /* the invoker */ 1637c478bd9Sstevel@tonic-gate static int dosyslog = 0; /* use syslog? */ 1647c478bd9Sstevel@tonic-gate char *myname; 1657c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 16657c40785SJoep Vesseur int pam_flags = 0; 1677c478bd9Sstevel@tonic-gate boolean_t embedded = B_FALSE; 1687c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate int 1717c478bd9Sstevel@tonic-gate main(int argc, char **argv) 1727c478bd9Sstevel@tonic-gate { 1737c478bd9Sstevel@tonic-gate #ifndef DYNAMIC_SU 1747c478bd9Sstevel@tonic-gate struct spwd sp; 1757c478bd9Sstevel@tonic-gate char spbuf[1024]; /* buffer for getspnam_r() */ 1767c478bd9Sstevel@tonic-gate char *password; 1775435d801Sgww #endif /* !DYNAMIC_SU */ 1787c478bd9Sstevel@tonic-gate char *nptr; 1797c478bd9Sstevel@tonic-gate char *pshell; 1807c478bd9Sstevel@tonic-gate int eflag = 0; 1817c478bd9Sstevel@tonic-gate int envidx = 0; 1827c478bd9Sstevel@tonic-gate uid_t uid; 1837c478bd9Sstevel@tonic-gate gid_t gid; 1847c478bd9Sstevel@tonic-gate char *dir, *shprog, *name; 1857c478bd9Sstevel@tonic-gate char *ptr; 1867c478bd9Sstevel@tonic-gate char *prog = argv[0]; 1877c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 1887c478bd9Sstevel@tonic-gate int sleeptime = SLEEPTIME; 1897c478bd9Sstevel@tonic-gate char **pam_env = 0; 1907c478bd9Sstevel@tonic-gate int flags = 0; 1917c478bd9Sstevel@tonic-gate int retcode; 1927c478bd9Sstevel@tonic-gate int idx = 0; 1937c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 1945435d801Sgww int pw_change = PW_FALSE; 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 1977c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 1987c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ 1997c478bd9Sstevel@tonic-gate #endif 2007c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate myname = tail(argv[0]); 2037c478bd9Sstevel@tonic-gate 2045435d801Sgww #ifdef DYNAMIC_SU 2057c478bd9Sstevel@tonic-gate if (strcmp(myname, EMBEDDED_NAME) == 0) { 2067c478bd9Sstevel@tonic-gate embedded = B_TRUE; 2077c478bd9Sstevel@tonic-gate setbuf(stdin, NULL); 2087c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 2097c478bd9Sstevel@tonic-gate readinitblock(); 2107c478bd9Sstevel@tonic-gate } 2115435d801Sgww #endif /* DYNAMIC_SU */ 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate if (argc > 1 && *argv[1] == '-') { 2147c478bd9Sstevel@tonic-gate /* Explicitly check for just `-' (no trailing chars) */ 2157c478bd9Sstevel@tonic-gate if (strlen(argv[1]) == 1) { 2167c478bd9Sstevel@tonic-gate eflag++; /* set eflag if `-' is specified */ 2177c478bd9Sstevel@tonic-gate argv++; 2187c478bd9Sstevel@tonic-gate argc--; 2197c478bd9Sstevel@tonic-gate } else { 2207c478bd9Sstevel@tonic-gate message(USAGE, 2217c478bd9Sstevel@tonic-gate gettext("Usage: %s [-] [ username [ arg ... ] ]"), 2227c478bd9Sstevel@tonic-gate prog); 2237c478bd9Sstevel@tonic-gate exit(1); 2247c478bd9Sstevel@tonic-gate } 2257c478bd9Sstevel@tonic-gate } 2267c478bd9Sstevel@tonic-gate 2277c478bd9Sstevel@tonic-gate /* 2287c478bd9Sstevel@tonic-gate * Determine specified userid, get their password file entry, 2297c478bd9Sstevel@tonic-gate * and set variables to values in password file entry fields. 2307c478bd9Sstevel@tonic-gate */ 2317c478bd9Sstevel@tonic-gate if (argc > 1) { 2327c478bd9Sstevel@tonic-gate /* 2337c478bd9Sstevel@tonic-gate * Usernames can't start with a `-', so we check for that to 2347c478bd9Sstevel@tonic-gate * catch bad usage (like "su - -c ls"). 2357c478bd9Sstevel@tonic-gate */ 2367c478bd9Sstevel@tonic-gate if (*argv[1] == '-') { 2377c478bd9Sstevel@tonic-gate message(USAGE, 2387c478bd9Sstevel@tonic-gate gettext("Usage: %s [-] [ username [ arg ... ] ]"), 2397c478bd9Sstevel@tonic-gate prog); 2407c478bd9Sstevel@tonic-gate exit(1); 2417c478bd9Sstevel@tonic-gate } else 2427c478bd9Sstevel@tonic-gate nptr = argv[1]; /* use valid command-line username */ 2437c478bd9Sstevel@tonic-gate } else 2447c478bd9Sstevel@tonic-gate nptr = "root"; /* use default "root" username */ 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate if (defopen(DEFFILE) == 0) { 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate if (Sulog = defread("SULOG=")) 2497c478bd9Sstevel@tonic-gate Sulog = strdup(Sulog); 2507c478bd9Sstevel@tonic-gate if (Console = defread("CONSOLE=")) 2517c478bd9Sstevel@tonic-gate Console = strdup(Console); 2527c478bd9Sstevel@tonic-gate if (Path = defread("PATH=")) 2537c478bd9Sstevel@tonic-gate Path = strdup(Path); 2547c478bd9Sstevel@tonic-gate if (Supath = defread("SUPATH=")) 2557c478bd9Sstevel@tonic-gate Supath = strdup(Supath); 2567c478bd9Sstevel@tonic-gate if ((ptr = defread("SYSLOG=")) != NULL) 2577c478bd9Sstevel@tonic-gate dosyslog = strcmp(ptr, "YES") == 0; 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate (void) defopen(NULL); 2607c478bd9Sstevel@tonic-gate } 2617c478bd9Sstevel@tonic-gate (void) strlcat(path, (Path) ? Path : PATH, sizeof (path)); 2627c478bd9Sstevel@tonic-gate (void) strlcat(supath, (Supath) ? Supath : SUPATH, sizeof (supath)); 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate if ((ttyn = ttyname(0)) == NULL) 2657c478bd9Sstevel@tonic-gate if ((ttyn = ttyname(1)) == NULL) 2667c478bd9Sstevel@tonic-gate if ((ttyn = ttyname(2)) == NULL) 2677c478bd9Sstevel@tonic-gate ttyn = "/dev/???"; 2687c478bd9Sstevel@tonic-gate if ((username = cuserid(NULL)) == NULL) 2697c478bd9Sstevel@tonic-gate username = "(null)"; 2707c478bd9Sstevel@tonic-gate 2717c478bd9Sstevel@tonic-gate /* 2727c478bd9Sstevel@tonic-gate * if Sulog defined, create SULOG, if it does not exist, with 2737c478bd9Sstevel@tonic-gate * mode read/write user. Change owner and group to root 2747c478bd9Sstevel@tonic-gate */ 2757c478bd9Sstevel@tonic-gate if (Sulog != NULL) { 2767c478bd9Sstevel@tonic-gate (void) close(open(Sulog, O_WRONLY | O_APPEND | O_CREAT, 2777c478bd9Sstevel@tonic-gate (S_IRUSR|S_IWUSR))); 2787c478bd9Sstevel@tonic-gate (void) chown(Sulog, (uid_t)ROOT, (gid_t)ROOT); 2797c478bd9Sstevel@tonic-gate } 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 2827c478bd9Sstevel@tonic-gate if (pam_start(embedded ? EMBEDDED_NAME : "su", nptr, 2837c478bd9Sstevel@tonic-gate embedded ? &emb_pam_conv : &pam_conv, &pamh) != PAM_SUCCESS) 2847c478bd9Sstevel@tonic-gate exit(1); 2857c478bd9Sstevel@tonic-gate if (pam_set_item(pamh, PAM_TTY, ttyn) != PAM_SUCCESS) 2867c478bd9Sstevel@tonic-gate exit(1); 2877c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 2887c478bd9Sstevel@tonic-gate 2897c478bd9Sstevel@tonic-gate openlog("su", LOG_CONS, LOG_AUTH); 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate /* 2945435d801Sgww * Use the same value of sleeptime and password required that 2955435d801Sgww * login(1) uses. 2965435d801Sgww * This is obtained by reading the file /etc/default/login 2975435d801Sgww * using the def*() functions 2985435d801Sgww */ 2995435d801Sgww if (defopen(DEFAULT_LOGIN) == 0) { 3005435d801Sgww if ((ptr = defread("SLEEPTIME=")) != NULL) { 3015435d801Sgww sleeptime = atoi(ptr); 3025435d801Sgww if (sleeptime < 0 || sleeptime > 5) 3035435d801Sgww sleeptime = SLEEPTIME; 3045435d801Sgww } 3055435d801Sgww 3065435d801Sgww if ((ptr = defread("PASSREQ=")) != NULL && 3075435d801Sgww strcasecmp("YES", ptr) == 0) 30857c40785SJoep Vesseur pam_flags |= PAM_DISALLOW_NULL_AUTHTOK; 3095435d801Sgww 3105435d801Sgww (void) defopen((char *)NULL); 3115435d801Sgww } 3125435d801Sgww /* 3137c478bd9Sstevel@tonic-gate * Ignore SIGQUIT and SIGINT 3147c478bd9Sstevel@tonic-gate */ 3157c478bd9Sstevel@tonic-gate (void) signal(SIGQUIT, SIG_IGN); 3167c478bd9Sstevel@tonic-gate (void) signal(SIGINT, SIG_IGN); 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate /* call pam_authenticate() to authenticate the user through PAM */ 3197c478bd9Sstevel@tonic-gate if (getpwnam_r(nptr, &pwd, pwdbuf, sizeof (pwdbuf)) == NULL) 3207c478bd9Sstevel@tonic-gate retcode = PAM_USER_UNKNOWN; 3217c478bd9Sstevel@tonic-gate else if ((flags = (getuid() != (uid_t)ROOT)) != 0) { 32257c40785SJoep Vesseur retcode = pam_authenticate(pamh, pam_flags); 3237c478bd9Sstevel@tonic-gate } else /* root user does not need to authenticate */ 3247c478bd9Sstevel@tonic-gate retcode = PAM_SUCCESS; 3257c478bd9Sstevel@tonic-gate 3267c478bd9Sstevel@tonic-gate if (retcode != PAM_SUCCESS) { 3277c478bd9Sstevel@tonic-gate /* 3285435d801Sgww * 1st step: audit and log the error. 3297c478bd9Sstevel@tonic-gate * 2nd step: sleep. 3307c478bd9Sstevel@tonic-gate * 3rd step: print out message to user. 3317c478bd9Sstevel@tonic-gate */ 33209295472Sgww /* don't let audit_failure distinguish a role here */ 33309295472Sgww audit_failure(PW_FALSE, NULL, nptr, retcode); 3347c478bd9Sstevel@tonic-gate switch (retcode) { 3357c478bd9Sstevel@tonic-gate case PAM_USER_UNKNOWN: 3367c478bd9Sstevel@tonic-gate closelog(); 3377c478bd9Sstevel@tonic-gate (void) sleep(sleeptime); 3387c478bd9Sstevel@tonic-gate message(ERR, gettext("Unknown id: %s"), nptr); 3397c478bd9Sstevel@tonic-gate break; 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate case PAM_AUTH_ERR: 3427c478bd9Sstevel@tonic-gate if (Sulog != NULL) 3437c478bd9Sstevel@tonic-gate log(Sulog, nptr, 0); /* log entry */ 3447c478bd9Sstevel@tonic-gate if (dosyslog) 3457c478bd9Sstevel@tonic-gate syslog(LOG_CRIT, "'su %s' failed for %s on %s", 3467c478bd9Sstevel@tonic-gate pwd.pw_name, username, ttyn); 3477c478bd9Sstevel@tonic-gate closelog(); 3487c478bd9Sstevel@tonic-gate (void) sleep(sleeptime); 3497c478bd9Sstevel@tonic-gate message(ERR, gettext("Sorry")); 3507c478bd9Sstevel@tonic-gate break; 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate case PAM_CONV_ERR: 3537c478bd9Sstevel@tonic-gate default: 3547c478bd9Sstevel@tonic-gate if (dosyslog) 3557c478bd9Sstevel@tonic-gate syslog(LOG_CRIT, "'su %s' failed for %s on %s", 3567c478bd9Sstevel@tonic-gate pwd.pw_name, username, ttyn); 3577c478bd9Sstevel@tonic-gate closelog(); 3587c478bd9Sstevel@tonic-gate (void) sleep(sleeptime); 3597c478bd9Sstevel@tonic-gate message(ERR, gettext("Sorry")); 3607c478bd9Sstevel@tonic-gate break; 3617c478bd9Sstevel@tonic-gate } 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate (void) signal(SIGQUIT, SIG_DFL); 3647c478bd9Sstevel@tonic-gate (void) signal(SIGINT, SIG_DFL); 3657c478bd9Sstevel@tonic-gate exit(1); 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate if (flags) 3685435d801Sgww validate(username, &pw_change); 3697c478bd9Sstevel@tonic-gate if (pam_setcred(pamh, PAM_REINITIALIZE_CRED) != PAM_SUCCESS) { 3707c478bd9Sstevel@tonic-gate message(ERR, gettext("unable to set credentials")); 3717c478bd9Sstevel@tonic-gate exit(2); 3727c478bd9Sstevel@tonic-gate } 3737c478bd9Sstevel@tonic-gate if (dosyslog) 37486ecf0b4SJan Kryl syslog(pwd.pw_uid == 0 ? LOG_NOTICE : LOG_INFO, 3757c478bd9Sstevel@tonic-gate "'su %s' succeeded for %s on %s", 3767c478bd9Sstevel@tonic-gate pwd.pw_name, username, ttyn); 3777c478bd9Sstevel@tonic-gate closelog(); 3787c478bd9Sstevel@tonic-gate (void) signal(SIGQUIT, SIG_DFL); 3797c478bd9Sstevel@tonic-gate (void) signal(SIGINT, SIG_DFL); 3805435d801Sgww #else /* !DYNAMIC_SU */ 3817c478bd9Sstevel@tonic-gate if ((getpwnam_r(nptr, &pwd, pwdbuf, sizeof (pwdbuf)) == NULL) || 3827c478bd9Sstevel@tonic-gate (getspnam_r(nptr, &sp, spbuf, sizeof (spbuf)) == NULL)) { 3837c478bd9Sstevel@tonic-gate message(ERR, gettext("Unknown id: %s"), nptr); 38409295472Sgww audit_failure(PW_FALSE, NULL, nptr, PAM_USER_UNKNOWN); 3857c478bd9Sstevel@tonic-gate closelog(); 3867c478bd9Sstevel@tonic-gate exit(1); 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate /* 3907c478bd9Sstevel@tonic-gate * Prompt for password if invoking user is not root or 3917c478bd9Sstevel@tonic-gate * if specified(new) user requires a password 3927c478bd9Sstevel@tonic-gate */ 3937c478bd9Sstevel@tonic-gate if (sp.sp_pwdp[0] == '\0' || getuid() == (uid_t)ROOT) 3947c478bd9Sstevel@tonic-gate goto ok; 3957c478bd9Sstevel@tonic-gate password = getpass(gettext("Password:")); 3967c478bd9Sstevel@tonic-gate 3977c478bd9Sstevel@tonic-gate if ((strcmp(sp.sp_pwdp, crypt(password, sp.sp_pwdp)) != 0)) { 3987c478bd9Sstevel@tonic-gate /* clear password file entry */ 3997c478bd9Sstevel@tonic-gate (void) memset((void *)spbuf, 0, sizeof (spbuf)); 4007c478bd9Sstevel@tonic-gate if (Sulog != NULL) 4017c478bd9Sstevel@tonic-gate log(Sulog, nptr, 0); /* log entry */ 4027c478bd9Sstevel@tonic-gate message(ERR, gettext("Sorry")); 40309295472Sgww audit_failure(PW_FALSE, NULL, nptr, PAM_AUTH_ERR); 4047c478bd9Sstevel@tonic-gate if (dosyslog) 4057c478bd9Sstevel@tonic-gate syslog(LOG_CRIT, "'su %s' failed for %s on %s", 4067c478bd9Sstevel@tonic-gate pwd.pw_name, username, ttyn); 4077c478bd9Sstevel@tonic-gate closelog(); 4087c478bd9Sstevel@tonic-gate exit(2); 4097c478bd9Sstevel@tonic-gate } 4107c478bd9Sstevel@tonic-gate /* clear password file entry */ 4117c478bd9Sstevel@tonic-gate (void) memset((void *)spbuf, 0, sizeof (spbuf)); 4127c478bd9Sstevel@tonic-gate ok: 4135435d801Sgww /* update audit session in a non-pam environment */ 4145435d801Sgww update_audit(&pwd); 4157c478bd9Sstevel@tonic-gate if (dosyslog) 41686ecf0b4SJan Kryl syslog(pwd.pw_uid == 0 ? LOG_NOTICE : LOG_INFO, 4177c478bd9Sstevel@tonic-gate "'su %s' succeeded for %s on %s", 4187c478bd9Sstevel@tonic-gate pwd.pw_name, username, ttyn); 4195435d801Sgww #endif /* DYNAMIC_SU */ 4207c478bd9Sstevel@tonic-gate 4215435d801Sgww audit_success(pw_change, &pwd); 4227c478bd9Sstevel@tonic-gate uid = pwd.pw_uid; 4237c478bd9Sstevel@tonic-gate gid = pwd.pw_gid; 4247c478bd9Sstevel@tonic-gate dir = strdup(pwd.pw_dir); 4257c478bd9Sstevel@tonic-gate shprog = strdup(pwd.pw_shell); 4267c478bd9Sstevel@tonic-gate name = strdup(pwd.pw_name); 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate if (Sulog != NULL) 4297c478bd9Sstevel@tonic-gate log(Sulog, nptr, 1); /* log entry */ 4307c478bd9Sstevel@tonic-gate 4317c478bd9Sstevel@tonic-gate /* set user and group ids to specified user */ 4327c478bd9Sstevel@tonic-gate 4337c478bd9Sstevel@tonic-gate /* set the real (and effective) GID */ 4347c478bd9Sstevel@tonic-gate if (setgid(gid) == -1) { 4357c478bd9Sstevel@tonic-gate message(ERR, gettext("Invalid GID")); 4367c478bd9Sstevel@tonic-gate exit(2); 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate /* Initialize the supplementary group access list. */ 4397c478bd9Sstevel@tonic-gate if (!nptr) 4407c478bd9Sstevel@tonic-gate exit(2); 4417c478bd9Sstevel@tonic-gate if (initgroups(nptr, gid) == -1) { 4427c478bd9Sstevel@tonic-gate exit(2); 4437c478bd9Sstevel@tonic-gate } 4447c478bd9Sstevel@tonic-gate /* set the real (and effective) UID */ 4457c478bd9Sstevel@tonic-gate if (setuid(uid) == -1) { 4467c478bd9Sstevel@tonic-gate message(ERR, gettext("Invalid UID")); 4477c478bd9Sstevel@tonic-gate exit(2); 4487c478bd9Sstevel@tonic-gate } 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate /* 4517c478bd9Sstevel@tonic-gate * If new user's shell field is neither NULL nor equal to /usr/bin/sh, 4527c478bd9Sstevel@tonic-gate * set: 4537c478bd9Sstevel@tonic-gate * 4547c478bd9Sstevel@tonic-gate * pshell = their shell 4557c478bd9Sstevel@tonic-gate * su = [-]last component of shell's pathname 4567c478bd9Sstevel@tonic-gate * 4577c478bd9Sstevel@tonic-gate * Otherwise, set the shell to /usr/bin/sh and set argv[0] to '[-]su'. 4587c478bd9Sstevel@tonic-gate */ 4597c478bd9Sstevel@tonic-gate if (shprog[0] != '\0' && strcmp(shell, shprog) != 0) { 4607c478bd9Sstevel@tonic-gate char *p; 4617c478bd9Sstevel@tonic-gate 4627c478bd9Sstevel@tonic-gate pshell = shprog; 4637c478bd9Sstevel@tonic-gate (void) strcpy(su, eflag ? "-" : ""); 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate if ((p = strrchr(pshell, '/')) != NULL) 4667c478bd9Sstevel@tonic-gate (void) strlcat(su, p + 1, sizeof (su)); 4677c478bd9Sstevel@tonic-gate else 4687c478bd9Sstevel@tonic-gate (void) strlcat(su, pshell, sizeof (su)); 4697c478bd9Sstevel@tonic-gate } else { 4707c478bd9Sstevel@tonic-gate pshell = shell; 4717c478bd9Sstevel@tonic-gate (void) strcpy(su, eflag ? "-su" : "su"); 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate /* 4757c478bd9Sstevel@tonic-gate * set environment variables for new user; 4767c478bd9Sstevel@tonic-gate * arg0 for exec of shprog must now contain `-' 4777c478bd9Sstevel@tonic-gate * so that environment of new user is given 4787c478bd9Sstevel@tonic-gate */ 4797c478bd9Sstevel@tonic-gate if (eflag) { 4807c478bd9Sstevel@tonic-gate int j; 4817c478bd9Sstevel@tonic-gate char *var; 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate if (strlen(dir) == 0) { 4847c478bd9Sstevel@tonic-gate (void) strcpy(dir, "/"); 4857c478bd9Sstevel@tonic-gate message(WARN, gettext("No directory! Using home=/")); 4867c478bd9Sstevel@tonic-gate } 4877c478bd9Sstevel@tonic-gate (void) strlcat(homedir, dir, sizeof (homedir)); 4887c478bd9Sstevel@tonic-gate (void) strlcat(logname, name, sizeof (logname)); 4897c478bd9Sstevel@tonic-gate if (hz = getenv("HZ")) 4907c478bd9Sstevel@tonic-gate (void) strlcat(hzname, hz, sizeof (hzname)); 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate (void) strlcat(shelltyp, pshell, sizeof (shelltyp)); 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate if (chdir(dir) < 0) { 4957c478bd9Sstevel@tonic-gate message(ERR, gettext("No directory!")); 4967c478bd9Sstevel@tonic-gate exit(1); 4977c478bd9Sstevel@tonic-gate } 4987c478bd9Sstevel@tonic-gate envinit[envidx = 0] = homedir; 4997c478bd9Sstevel@tonic-gate envinit[++envidx] = ((uid == (uid_t)ROOT) ? supath : path); 5007c478bd9Sstevel@tonic-gate envinit[++envidx] = logname; 5017c478bd9Sstevel@tonic-gate envinit[++envidx] = hzname; 5027c478bd9Sstevel@tonic-gate if ((term = getenv("TERM")) != NULL) { 5037c478bd9Sstevel@tonic-gate (void) strlcat(termtyp, term, sizeof (termtyp)); 5047c478bd9Sstevel@tonic-gate envinit[++envidx] = termtyp; 5057c478bd9Sstevel@tonic-gate } 5067c478bd9Sstevel@tonic-gate envinit[++envidx] = shelltyp; 5077c478bd9Sstevel@tonic-gate 5087c478bd9Sstevel@tonic-gate (void) strlcat(mail, name, sizeof (mail)); 5097c478bd9Sstevel@tonic-gate envinit[++envidx] = mail; 5107c478bd9Sstevel@tonic-gate 5117c478bd9Sstevel@tonic-gate /* 5127c478bd9Sstevel@tonic-gate * Fetch the relevant locale/TZ environment variables from 5137c478bd9Sstevel@tonic-gate * the inherited environment. 5147c478bd9Sstevel@tonic-gate * 5157c478bd9Sstevel@tonic-gate * We have a priority here for setting TZ. If TZ is set in 5167c478bd9Sstevel@tonic-gate * in the inherited environment, that value remains top 5177c478bd9Sstevel@tonic-gate * priority. If the file /etc/default/login has TIMEZONE set, 5187c478bd9Sstevel@tonic-gate * that has second highest priority. 5197c478bd9Sstevel@tonic-gate */ 5207c478bd9Sstevel@tonic-gate tznam[0] = '\0'; 5217c478bd9Sstevel@tonic-gate for (j = 0; initenv[j] != 0; j++) { 5227c478bd9Sstevel@tonic-gate if (initvar = getenv(initenv[j])) { 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate /* 5257c478bd9Sstevel@tonic-gate * Skip over values beginning with '/' for 5267c478bd9Sstevel@tonic-gate * security. 5277c478bd9Sstevel@tonic-gate */ 5287c478bd9Sstevel@tonic-gate if (initvar[0] == '/') continue; 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate if (strcmp(initenv[j], "TZ") == 0) { 5317c478bd9Sstevel@tonic-gate (void) strcpy(tznam, "TZ="); 5327c478bd9Sstevel@tonic-gate (void) strlcat(tznam, initvar, 5337c478bd9Sstevel@tonic-gate sizeof (tznam)); 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate } else { 5367c478bd9Sstevel@tonic-gate var = (char *) 5377c478bd9Sstevel@tonic-gate malloc(strlen(initenv[j]) 5387c478bd9Sstevel@tonic-gate + strlen(initvar) 5397c478bd9Sstevel@tonic-gate + 2); 5407c478bd9Sstevel@tonic-gate (void) strcpy(var, initenv[j]); 5417c478bd9Sstevel@tonic-gate (void) strcat(var, "="); 5427c478bd9Sstevel@tonic-gate (void) strcat(var, initvar); 5437c478bd9Sstevel@tonic-gate envinit[++envidx] = var; 5447c478bd9Sstevel@tonic-gate } 5457c478bd9Sstevel@tonic-gate } 5467c478bd9Sstevel@tonic-gate } 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate /* 5497c478bd9Sstevel@tonic-gate * Check if TZ was found. If not then try to read it from 5507c478bd9Sstevel@tonic-gate * /etc/default/login. 5517c478bd9Sstevel@tonic-gate */ 5527c478bd9Sstevel@tonic-gate if (tznam[0] == '\0') { 5537c478bd9Sstevel@tonic-gate if (defopen(DEFAULT_LOGIN) == 0) { 5547c478bd9Sstevel@tonic-gate if (initvar = defread("TIMEZONE=")) { 5557c478bd9Sstevel@tonic-gate (void) strcpy(tznam, "TZ="); 5567c478bd9Sstevel@tonic-gate (void) strlcat(tznam, initvar, 5577c478bd9Sstevel@tonic-gate sizeof (tznam)); 5587c478bd9Sstevel@tonic-gate } 5597c478bd9Sstevel@tonic-gate (void) defopen(NULL); 5607c478bd9Sstevel@tonic-gate } 5617c478bd9Sstevel@tonic-gate } 5627c478bd9Sstevel@tonic-gate 5637c478bd9Sstevel@tonic-gate if (tznam[0] != '\0') 5647c478bd9Sstevel@tonic-gate envinit[++envidx] = tznam; 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 5677c478bd9Sstevel@tonic-gate /* 5687c478bd9Sstevel@tonic-gate * set the PAM environment variables - 5697c478bd9Sstevel@tonic-gate * check for legal environment variables 5707c478bd9Sstevel@tonic-gate */ 5717c478bd9Sstevel@tonic-gate if ((pam_env = pam_getenvlist(pamh)) != 0) { 5727c478bd9Sstevel@tonic-gate while (pam_env[idx] != 0) { 5737c478bd9Sstevel@tonic-gate if (envidx + 2 < ELIM && 5747c478bd9Sstevel@tonic-gate legalenvvar(pam_env[idx])) { 5757c478bd9Sstevel@tonic-gate envinit[++envidx] = pam_env[idx]; 5767c478bd9Sstevel@tonic-gate } 5777c478bd9Sstevel@tonic-gate idx++; 5787c478bd9Sstevel@tonic-gate } 5797c478bd9Sstevel@tonic-gate } 5805435d801Sgww #endif /* DYNAMIC_SU */ 5817c478bd9Sstevel@tonic-gate envinit[++envidx] = NULL; 5827c478bd9Sstevel@tonic-gate environ = envinit; 5837c478bd9Sstevel@tonic-gate } else { 5847c478bd9Sstevel@tonic-gate char **pp = environ, **qq, *p; 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate while ((p = *pp) != NULL) { 5877c478bd9Sstevel@tonic-gate if (*p == 'L' && p[1] == 'D' && p[2] == '_') { 5887c478bd9Sstevel@tonic-gate for (qq = pp; (*qq = qq[1]) != NULL; qq++) 5897c478bd9Sstevel@tonic-gate ; 5907c478bd9Sstevel@tonic-gate /* pp is not advanced */ 5917c478bd9Sstevel@tonic-gate } else { 5927c478bd9Sstevel@tonic-gate pp++; 5937c478bd9Sstevel@tonic-gate } 5947c478bd9Sstevel@tonic-gate } 5957c478bd9Sstevel@tonic-gate } 5967c478bd9Sstevel@tonic-gate 5977c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 5987c478bd9Sstevel@tonic-gate if (pamh) 5997c478bd9Sstevel@tonic-gate (void) pam_end(pamh, PAM_SUCCESS); 6005435d801Sgww #endif /* DYNAMIC_SU */ 6017c478bd9Sstevel@tonic-gate 6027c478bd9Sstevel@tonic-gate /* 6037c478bd9Sstevel@tonic-gate * if new user is root: 6047c478bd9Sstevel@tonic-gate * if CONSOLE defined, log entry there; 6057c478bd9Sstevel@tonic-gate * if eflag not set, change environment to that of root. 6067c478bd9Sstevel@tonic-gate */ 6077c478bd9Sstevel@tonic-gate if (uid == (uid_t)ROOT) { 6087c478bd9Sstevel@tonic-gate if (Console != NULL) 6097c478bd9Sstevel@tonic-gate if (strcmp(ttyn, Console) != 0) { 6107c478bd9Sstevel@tonic-gate (void) signal(SIGALRM, to); 6117c478bd9Sstevel@tonic-gate (void) alarm(30); 6127c478bd9Sstevel@tonic-gate log(Console, nptr, 1); 6137c478bd9Sstevel@tonic-gate (void) alarm(0); 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate if (!eflag) 6167c478bd9Sstevel@tonic-gate envalt(); 6177c478bd9Sstevel@tonic-gate } 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate /* 6207c478bd9Sstevel@tonic-gate * Default for SIGCPU and SIGXFSZ. Shells inherit 6217c478bd9Sstevel@tonic-gate * signal disposition from parent. And the 6227c478bd9Sstevel@tonic-gate * shells should have default dispositions for these 6237c478bd9Sstevel@tonic-gate * signals. 6247c478bd9Sstevel@tonic-gate */ 6257c478bd9Sstevel@tonic-gate (void) signal(SIGXCPU, SIG_DFL); 6267c478bd9Sstevel@tonic-gate (void) signal(SIGXFSZ, SIG_DFL); 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 6297c478bd9Sstevel@tonic-gate if (embedded) { 6307c478bd9Sstevel@tonic-gate (void) puts("SUCCESS"); 6317c478bd9Sstevel@tonic-gate /* 6327c478bd9Sstevel@tonic-gate * After this point, we're no longer talking the 6337c478bd9Sstevel@tonic-gate * embedded_su protocol, so turn it off. 6347c478bd9Sstevel@tonic-gate */ 6357c478bd9Sstevel@tonic-gate embedded = B_FALSE; 6367c478bd9Sstevel@tonic-gate } 6377c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate /* 6407c478bd9Sstevel@tonic-gate * if additional arguments, exec shell program with array 6417c478bd9Sstevel@tonic-gate * of pointers to arguments: 6427c478bd9Sstevel@tonic-gate * -> if shell = default, then su = [-]su 6437c478bd9Sstevel@tonic-gate * -> if shell != default, then su = [-]last component of 6447c478bd9Sstevel@tonic-gate * shell's pathname 6457c478bd9Sstevel@tonic-gate * 6467c478bd9Sstevel@tonic-gate * if no additional arguments, exec shell with arg0 of su 6477c478bd9Sstevel@tonic-gate * where: 6487c478bd9Sstevel@tonic-gate * -> if shell = default, then su = [-]su 6497c478bd9Sstevel@tonic-gate * -> if shell != default, then su = [-]last component of 6507c478bd9Sstevel@tonic-gate * shell's pathname 6517c478bd9Sstevel@tonic-gate */ 6527c478bd9Sstevel@tonic-gate if (argc > 2) { 6537c478bd9Sstevel@tonic-gate argv[1] = su; 6547c478bd9Sstevel@tonic-gate (void) execv(pshell, &argv[1]); 6557c478bd9Sstevel@tonic-gate } else 6567c478bd9Sstevel@tonic-gate (void) execl(pshell, su, 0); 6577c478bd9Sstevel@tonic-gate 6587c478bd9Sstevel@tonic-gate 6597c478bd9Sstevel@tonic-gate /* 6607c478bd9Sstevel@tonic-gate * Try to clean up after an administrator who has made a mistake 6617c478bd9Sstevel@tonic-gate * configuring root's shell; if root's shell is other than /sbin/sh, 6627c478bd9Sstevel@tonic-gate * try exec'ing /sbin/sh instead. 6637c478bd9Sstevel@tonic-gate */ 6647c478bd9Sstevel@tonic-gate if ((uid == (uid_t)ROOT) && (strcmp(name, "root") == 0) && 6657c478bd9Sstevel@tonic-gate (strcmp(safe_shell, pshell) != 0)) { 6667c478bd9Sstevel@tonic-gate message(WARN, 6677c478bd9Sstevel@tonic-gate gettext("No shell %s. Trying fallback shell %s."), 6687c478bd9Sstevel@tonic-gate pshell, safe_shell); 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate if (eflag) { 6717c478bd9Sstevel@tonic-gate (void) strcpy(su, "-sh"); 6727c478bd9Sstevel@tonic-gate (void) strlcpy(shelltyp + strlen("SHELL="), 6737c478bd9Sstevel@tonic-gate safe_shell, sizeof (shelltyp) - strlen("SHELL=")); 6747c478bd9Sstevel@tonic-gate } else { 6757c478bd9Sstevel@tonic-gate (void) strcpy(su, "sh"); 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate if (argc > 2) { 6797c478bd9Sstevel@tonic-gate argv[1] = su; 6807c478bd9Sstevel@tonic-gate (void) execv(safe_shell, &argv[1]); 6817c478bd9Sstevel@tonic-gate } else { 6827c478bd9Sstevel@tonic-gate (void) execl(safe_shell, su, 0); 6837c478bd9Sstevel@tonic-gate } 6847c478bd9Sstevel@tonic-gate message(ERR, gettext("Couldn't exec fallback shell %s: %s"), 6857c478bd9Sstevel@tonic-gate safe_shell, strerror(errno)); 6867c478bd9Sstevel@tonic-gate } else { 6877c478bd9Sstevel@tonic-gate message(ERR, gettext("No shell")); 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate return (3); 6907c478bd9Sstevel@tonic-gate } 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate /* 6937c478bd9Sstevel@tonic-gate * Environment altering routine - 6947c478bd9Sstevel@tonic-gate * This routine is called when a user is su'ing to root 6957c478bd9Sstevel@tonic-gate * without specifying the - flag. 6967c478bd9Sstevel@tonic-gate * The user's PATH and PS1 variables are reset 6977c478bd9Sstevel@tonic-gate * to the correct value for root. 6987c478bd9Sstevel@tonic-gate * All of the user's other environment variables retain 6997c478bd9Sstevel@tonic-gate * their current values after the su (if they are exported). 7007c478bd9Sstevel@tonic-gate */ 7017c478bd9Sstevel@tonic-gate static void 7027c478bd9Sstevel@tonic-gate envalt(void) 7037c478bd9Sstevel@tonic-gate { 7047c478bd9Sstevel@tonic-gate /* 7057c478bd9Sstevel@tonic-gate * If user has PATH variable in their environment, change its value 7067c478bd9Sstevel@tonic-gate * to /bin:/etc:/usr/bin ; 7077c478bd9Sstevel@tonic-gate * if user does not have PATH variable, add it to the user's 7087c478bd9Sstevel@tonic-gate * environment; 7097c478bd9Sstevel@tonic-gate * if either of the above fail, an error message is printed. 7107c478bd9Sstevel@tonic-gate */ 7117c478bd9Sstevel@tonic-gate if (putenv(supath) != 0) { 7127c478bd9Sstevel@tonic-gate message(ERR, 7137c478bd9Sstevel@tonic-gate gettext("unable to obtain memory to expand environment")); 7147c478bd9Sstevel@tonic-gate exit(4); 7157c478bd9Sstevel@tonic-gate } 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate /* 7187c478bd9Sstevel@tonic-gate * If user has PROMPT variable in their environment, change its value 7197c478bd9Sstevel@tonic-gate * to # ; 7207c478bd9Sstevel@tonic-gate * if user does not have PROMPT variable, add it to the user's 7217c478bd9Sstevel@tonic-gate * environment; 7227c478bd9Sstevel@tonic-gate * if either of the above fail, an error message is printed. 7237c478bd9Sstevel@tonic-gate */ 7247c478bd9Sstevel@tonic-gate if (putenv(suprmt) != 0) { 7257c478bd9Sstevel@tonic-gate message(ERR, 7267c478bd9Sstevel@tonic-gate gettext("unable to obtain memory to expand environment")); 7277c478bd9Sstevel@tonic-gate exit(4); 7287c478bd9Sstevel@tonic-gate } 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate /* 7327c478bd9Sstevel@tonic-gate * Logging routine - 7337c478bd9Sstevel@tonic-gate * where = SULOG or CONSOLE 7347c478bd9Sstevel@tonic-gate * towho = specified user ( user being su'ed to ) 7357c478bd9Sstevel@tonic-gate * how = 0 if su attempt failed; 1 if su attempt succeeded 7367c478bd9Sstevel@tonic-gate */ 7377c478bd9Sstevel@tonic-gate static void 7387c478bd9Sstevel@tonic-gate log(char *where, char *towho, int how) 7397c478bd9Sstevel@tonic-gate { 7407c478bd9Sstevel@tonic-gate FILE *logf; 7417c478bd9Sstevel@tonic-gate time_t now; 7427c478bd9Sstevel@tonic-gate struct tm *tmp; 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate /* 7457c478bd9Sstevel@tonic-gate * open SULOG or CONSOLE - if open fails, return 7467c478bd9Sstevel@tonic-gate */ 7477c478bd9Sstevel@tonic-gate if ((logf = fopen(where, "a")) == NULL) 7487c478bd9Sstevel@tonic-gate return; 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate now = time(0); 7517c478bd9Sstevel@tonic-gate tmp = localtime(&now); 7527c478bd9Sstevel@tonic-gate 7537c478bd9Sstevel@tonic-gate /* 7547c478bd9Sstevel@tonic-gate * write entry into SULOG or onto CONSOLE - if write fails, return 7557c478bd9Sstevel@tonic-gate */ 7567c478bd9Sstevel@tonic-gate (void) fprintf(logf, "SU %.2d/%.2d %.2d:%.2d %c %s %s-%s\n", 7577c478bd9Sstevel@tonic-gate tmp->tm_mon + 1, tmp->tm_mday, tmp->tm_hour, tmp->tm_min, 7587c478bd9Sstevel@tonic-gate how ? '+' : '-', ttyn + sizeof ("/dev/") - 1, username, towho); 7597c478bd9Sstevel@tonic-gate 7607c478bd9Sstevel@tonic-gate (void) fclose(logf); /* close SULOG or CONSOLE */ 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7647c478bd9Sstevel@tonic-gate static void 7657c478bd9Sstevel@tonic-gate to(int sig) 7667c478bd9Sstevel@tonic-gate {} 7677c478bd9Sstevel@tonic-gate 7685435d801Sgww /* 7695435d801Sgww * audit_success - audit successful su 7705435d801Sgww * 7715435d801Sgww * Entry process audit context established -- i.e., pam_setcred() 7725435d801Sgww * or equivalent called. 7735435d801Sgww * pw_change = PW_TRUE, if successful password change audit 7745435d801Sgww * required. 7755435d801Sgww * pwd = passwd entry for new user. 7765435d801Sgww */ 7775435d801Sgww 7785435d801Sgww static void 7795435d801Sgww audit_success(int pw_change, struct passwd *pwd) 7805435d801Sgww { 7815435d801Sgww adt_session_data_t *ah = NULL; 7825435d801Sgww adt_event_data_t *event; 78309295472Sgww au_event_t event_id = ADT_su; 78409295472Sgww userattr_t *user_entry; 78509295472Sgww char *kva_value; 7865435d801Sgww 7875435d801Sgww if (adt_start_session(&ah, NULL, ADT_USE_PROC_DATA) != 0) { 7885435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 7895435d801Sgww "adt_start_session(ADT_su): %m"); 7905435d801Sgww return; 7915435d801Sgww } 79209295472Sgww if (((user_entry = getusernam(pwd->pw_name)) != NULL) && 79309295472Sgww ((kva_value = kva_match((kva_t *)user_entry->attr, 79409295472Sgww USERATTR_TYPE_KW)) != NULL) && 79509295472Sgww ((strcmp(kva_value, USERATTR_TYPE_NONADMIN_KW) == 0) || 79609295472Sgww (strcmp(kva_value, USERATTR_TYPE_ADMIN_KW) == 0))) { 79709295472Sgww event_id = ADT_role_login; 79809295472Sgww } 79909295472Sgww free_userattr(user_entry); /* OK to use, checks for NULL */ 80009295472Sgww 8015435d801Sgww /* since proc uid/gid not yet updated */ 8025435d801Sgww if (adt_set_user(ah, pwd->pw_uid, pwd->pw_gid, pwd->pw_uid, 8035435d801Sgww pwd->pw_gid, NULL, ADT_USER) != 0) { 8045435d801Sgww syslog(LOG_AUTH | LOG_ERR, 8055435d801Sgww "adt_set_user(ADT_su, ADT_FAILURE): %m"); 8065435d801Sgww } 80709295472Sgww if ((event = adt_alloc_event(ah, event_id)) == NULL) { 8085435d801Sgww syslog(LOG_AUTH | LOG_ALERT, "adt_alloc_event(ADT_su): %m"); 8095435d801Sgww } else if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS) != 0) { 8105435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 8115435d801Sgww "adt_put_event(ADT_su, ADT_SUCCESS): %m"); 8125435d801Sgww } 8135435d801Sgww 8145435d801Sgww if (pw_change == PW_TRUE) { 8155435d801Sgww /* Also audit password change */ 8165435d801Sgww adt_free_event(event); 8175435d801Sgww if ((event = adt_alloc_event(ah, ADT_passwd)) == NULL) { 8185435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 8195435d801Sgww "adt_alloc_event(ADT_passwd): %m"); 8205435d801Sgww } else if (adt_put_event(event, ADT_SUCCESS, 8215435d801Sgww ADT_SUCCESS) != 0) { 8225435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 8235435d801Sgww "adt_put_event(ADT_passwd, ADT_SUCCESS): %m"); 8245435d801Sgww } 8255435d801Sgww } 8265435d801Sgww adt_free_event(event); 82709295472Sgww /* 82809295472Sgww * The preceeding code is a noop if audit isn't enabled, 82909295472Sgww * but, let's not make a new process when it's not necessary. 83009295472Sgww */ 83109295472Sgww if (adt_audit_enabled()) { 832a98aba88Sgww audit_logout(ah, event_id); /* fork to catch logout */ 83309295472Sgww } 83409295472Sgww (void) adt_end_session(ah); 83509295472Sgww } 83609295472Sgww 83709295472Sgww 83809295472Sgww /* 83909295472Sgww * audit_logout - audit successful su logout 84009295472Sgww * 84109295472Sgww * Entry ah = Successful su audit handle 84209295472Sgww * event_id = su event ID: ADT_su, ADT_role_login 84309295472Sgww * 84409295472Sgww * Exit Errors are just ignored and we go on. 84509295472Sgww * su logout event written. 84609295472Sgww */ 84709295472Sgww static void 84809295472Sgww audit_logout(adt_session_data_t *ah, au_event_t event_id) 84909295472Sgww { 85009295472Sgww adt_event_data_t *event; 85109295472Sgww int status; /* wait status */ 85209295472Sgww pid_t pid; 85309295472Sgww priv_set_t *priv; /* waiting process privs */ 85409295472Sgww 85509295472Sgww if (event_id == ADT_su) { 85609295472Sgww event_id = ADT_su_logout; 85709295472Sgww } else { 85809295472Sgww event_id = ADT_role_logout; 85909295472Sgww } 86009295472Sgww if ((event = adt_alloc_event(ah, event_id)) == NULL) { 86109295472Sgww syslog(LOG_AUTH | LOG_ALERT, 86209295472Sgww "adt_alloc_event(ADT_su_logout): %m"); 863a98aba88Sgww return; 86409295472Sgww } 865a98aba88Sgww if ((priv = priv_allocset()) == NULL) { 866a98aba88Sgww syslog(LOG_AUTH | LOG_ALERT, 867*634e26ecSCasper H.S. Dik "su audit_logout: could not alloc basic privs: %m"); 868a98aba88Sgww adt_free_event(event); 869a98aba88Sgww return; 870a98aba88Sgww } 871a98aba88Sgww 872a98aba88Sgww /* 873a98aba88Sgww * The child returns and continues su processing. 874a98aba88Sgww * The parent's sole job is to wait for child exit, write the 875a98aba88Sgww * logout audit record, and replay the child's exit code. 876a98aba88Sgww */ 877a98aba88Sgww if ((pid = fork()) == 0) { 878a98aba88Sgww /* child */ 879a98aba88Sgww 880a98aba88Sgww adt_free_event(event); 881a98aba88Sgww priv_freeset(priv); 882a98aba88Sgww return; 883a98aba88Sgww } 884a98aba88Sgww if (pid == -1) { 885a98aba88Sgww /* failure */ 886a98aba88Sgww 887a98aba88Sgww syslog(LOG_AUTH | LOG_ALERT, 888a98aba88Sgww "su audit_logout: could not fork: %m"); 889a98aba88Sgww adt_free_event(event); 890a98aba88Sgww priv_freeset(priv); 891a98aba88Sgww return; 892a98aba88Sgww } 893a98aba88Sgww 894a98aba88Sgww /* parent process */ 895a98aba88Sgww 896a98aba88Sgww /* 897a98aba88Sgww * When this routine is called, the current working 898a98aba88Sgww * directory is the unknown and there are unknown open 899a98aba88Sgww * files. For the waiting process, change the current 900a98aba88Sgww * directory to root and close open files so that 901a98aba88Sgww * directories can be unmounted if necessary. 902a98aba88Sgww */ 903a98aba88Sgww if (chdir("/") != 0) { 904a98aba88Sgww syslog(LOG_AUTH | LOG_ALERT, 905a98aba88Sgww "su audit_logout: could not chdir /: %m"); 906a98aba88Sgww } 907a98aba88Sgww /* 908a98aba88Sgww * Reduce privileges to just those needed. 909a98aba88Sgww */ 910*634e26ecSCasper H.S. Dik priv_basicset(priv); 911*634e26ecSCasper H.S. Dik (void) priv_delset(priv, PRIV_PROC_EXEC); 912*634e26ecSCasper H.S. Dik (void) priv_delset(priv, PRIV_PROC_FORK); 913*634e26ecSCasper H.S. Dik (void) priv_delset(priv, PRIV_PROC_INFO); 914*634e26ecSCasper H.S. Dik (void) priv_delset(priv, PRIV_PROC_SESSION); 915*634e26ecSCasper H.S. Dik (void) priv_delset(priv, PRIV_FILE_LINK_ANY); 916a98aba88Sgww if ((priv_addset(priv, PRIV_PROC_AUDIT) != 0) || 917a98aba88Sgww (setppriv(PRIV_SET, PRIV_PERMITTED, priv) != 0)) { 918a98aba88Sgww syslog(LOG_AUTH | LOG_ALERT, 919a98aba88Sgww "su audit_logout: could not reduce privs: %m"); 920a98aba88Sgww } 921a98aba88Sgww closefrom(0); 922a98aba88Sgww priv_freeset(priv); 923a98aba88Sgww while (pid != waitpid(pid, &status, 0)) 924a98aba88Sgww continue; 92509295472Sgww 92609295472Sgww (void) adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS); 92709295472Sgww adt_free_event(event); 92809295472Sgww (void) adt_end_session(ah); 929a98aba88Sgww exit(WEXITSTATUS(status)); 9305435d801Sgww } 9315435d801Sgww 9325435d801Sgww 9335435d801Sgww /* 9345435d801Sgww * audit_failure - audit failed su 9355435d801Sgww * 9365435d801Sgww * Entry New audit context not set. 9375435d801Sgww * pw_change == PW_FALSE, if no password change requested. 9385435d801Sgww * PW_FAILED, if failed password change audit 9395435d801Sgww * required. 94009295472Sgww * pwd = NULL, or password entry to use. 94109295472Sgww * user = username entered. Add to record if pwd == NULL. 9425435d801Sgww * pamerr = PAM error code; reason for failure. 9435435d801Sgww */ 9445435d801Sgww 9455435d801Sgww static void 94609295472Sgww audit_failure(int pw_change, struct passwd *pwd, char *user, int pamerr) 9475435d801Sgww { 9485435d801Sgww adt_session_data_t *ah; /* audit session handle */ 9495435d801Sgww adt_event_data_t *event; /* event to generate */ 95009295472Sgww au_event_t event_id = ADT_su; 95109295472Sgww userattr_t *user_entry; 95209295472Sgww char *kva_value; 9535435d801Sgww 9545435d801Sgww if (adt_start_session(&ah, NULL, ADT_USE_PROC_DATA) != 0) { 9555435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 9565435d801Sgww "adt_start_session(ADT_su, ADT_FAILURE): %m"); 9575435d801Sgww return; 9585435d801Sgww } 95909295472Sgww 9605435d801Sgww if (pwd != NULL) { 9615435d801Sgww /* target user authenticated, merge audit state */ 9625435d801Sgww if (adt_set_user(ah, pwd->pw_uid, pwd->pw_gid, pwd->pw_uid, 9635435d801Sgww pwd->pw_gid, NULL, ADT_UPDATE) != 0) { 9645435d801Sgww syslog(LOG_AUTH | LOG_ERR, 9655435d801Sgww "adt_set_user(ADT_su, ADT_FAILURE): %m"); 9665435d801Sgww } 96709295472Sgww if (((user_entry = getusernam(pwd->pw_name)) != NULL) && 96809295472Sgww ((kva_value = kva_match((kva_t *)user_entry->attr, 96909295472Sgww USERATTR_TYPE_KW)) != NULL) && 97009295472Sgww ((strcmp(kva_value, USERATTR_TYPE_NONADMIN_KW) == 0) || 97109295472Sgww (strcmp(kva_value, USERATTR_TYPE_ADMIN_KW) == 0))) { 97209295472Sgww event_id = ADT_role_login; 9735435d801Sgww } 97409295472Sgww free_userattr(user_entry); /* OK to use, checks for NULL */ 97509295472Sgww } 97609295472Sgww if ((event = adt_alloc_event(ah, event_id)) == NULL) { 9775435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 9785435d801Sgww "adt_alloc_event(ADT_su, ADT_FAILURE): %m"); 9795435d801Sgww return; 98009295472Sgww } 98109295472Sgww /* 98209295472Sgww * can't tell if user not found is a role, so always use su 98309295472Sgww * If we do pass in pwd when the JNI is fixed, then can 98409295472Sgww * distinguish and set name in both su and role_login 98509295472Sgww */ 98609295472Sgww if (pwd == NULL) { 98709295472Sgww /* 98809295472Sgww * this should be "fail_user" rather than "message" 98909295472Sgww * see adt_xml. The JNI breaks, so for now we leave 99009295472Sgww * this alone. 99109295472Sgww */ 99209295472Sgww event->adt_su.message = user; 99309295472Sgww } 99409295472Sgww if (adt_put_event(event, ADT_FAILURE, 9955435d801Sgww ADT_FAIL_PAM + pamerr) != 0) { 9965435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 9975435d801Sgww "adt_put_event(ADT_su(ADT_FAIL, %s): %m", 9985435d801Sgww pam_strerror(pamh, pamerr)); 9995435d801Sgww } 10005435d801Sgww if (pw_change != PW_FALSE) { 10015435d801Sgww /* Also audit password change failed */ 10025435d801Sgww adt_free_event(event); 10035435d801Sgww if ((event = adt_alloc_event(ah, ADT_passwd)) == NULL) { 10045435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 1005a98aba88Sgww "su: adt_alloc_event(ADT_passwd): %m"); 10065435d801Sgww } else if (adt_put_event(event, ADT_FAILURE, 10075435d801Sgww ADT_FAIL_PAM + pamerr) != 0) { 10085435d801Sgww syslog(LOG_AUTH | LOG_ALERT, 1009a98aba88Sgww "su: adt_put_event(ADT_passwd, ADT_FAILURE): %m"); 10105435d801Sgww } 10115435d801Sgww } 10125435d801Sgww adt_free_event(event); 101309295472Sgww (void) adt_end_session(ah); 10145435d801Sgww } 10155435d801Sgww 10167c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 10177c478bd9Sstevel@tonic-gate /* 10187c478bd9Sstevel@tonic-gate * su_conv(): 10197c478bd9Sstevel@tonic-gate * This is the conv (conversation) function called from 10207c478bd9Sstevel@tonic-gate * a PAM authentication module to print error messages 10217c478bd9Sstevel@tonic-gate * or garner information from the user. 10227c478bd9Sstevel@tonic-gate */ 10237c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 10247c478bd9Sstevel@tonic-gate static int 10257c478bd9Sstevel@tonic-gate su_conv(int num_msg, struct pam_message **msg, struct pam_response **response, 10267c478bd9Sstevel@tonic-gate void *appdata_ptr) 10277c478bd9Sstevel@tonic-gate { 10287c478bd9Sstevel@tonic-gate struct pam_message *m; 10297c478bd9Sstevel@tonic-gate struct pam_response *r; 10307c478bd9Sstevel@tonic-gate char *temp; 10317c478bd9Sstevel@tonic-gate int k; 10327c478bd9Sstevel@tonic-gate char respbuf[PAM_MAX_RESP_SIZE]; 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate if (num_msg <= 0) 10357c478bd9Sstevel@tonic-gate return (PAM_CONV_ERR); 10367c478bd9Sstevel@tonic-gate 10377c478bd9Sstevel@tonic-gate *response = (struct pam_response *)calloc(num_msg, 10387c478bd9Sstevel@tonic-gate sizeof (struct pam_response)); 10397c478bd9Sstevel@tonic-gate if (*response == NULL) 10407c478bd9Sstevel@tonic-gate return (PAM_BUF_ERR); 10417c478bd9Sstevel@tonic-gate 10427c478bd9Sstevel@tonic-gate k = num_msg; 10437c478bd9Sstevel@tonic-gate m = *msg; 10447c478bd9Sstevel@tonic-gate r = *response; 10457c478bd9Sstevel@tonic-gate while (k--) { 10467c478bd9Sstevel@tonic-gate 10477c478bd9Sstevel@tonic-gate switch (m->msg_style) { 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate case PAM_PROMPT_ECHO_OFF: 10507c478bd9Sstevel@tonic-gate errno = 0; 10517c478bd9Sstevel@tonic-gate temp = getpassphrase(m->msg); 10527c478bd9Sstevel@tonic-gate if (errno == EINTR) 10537c478bd9Sstevel@tonic-gate return (PAM_CONV_ERR); 10547c478bd9Sstevel@tonic-gate if (temp != NULL) { 10557c478bd9Sstevel@tonic-gate r->resp = strdup(temp); 10567c478bd9Sstevel@tonic-gate if (r->resp == NULL) { 10577c478bd9Sstevel@tonic-gate freeresponse(num_msg, response); 10587c478bd9Sstevel@tonic-gate return (PAM_BUF_ERR); 10597c478bd9Sstevel@tonic-gate } 10607c478bd9Sstevel@tonic-gate } 10617c478bd9Sstevel@tonic-gate break; 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate case PAM_PROMPT_ECHO_ON: 10647c478bd9Sstevel@tonic-gate if (m->msg != NULL) { 10657c478bd9Sstevel@tonic-gate (void) fputs(m->msg, stdout); 10667c478bd9Sstevel@tonic-gate } 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate (void) fgets(respbuf, sizeof (respbuf), stdin); 10697c478bd9Sstevel@tonic-gate temp = strchr(respbuf, '\n'); 10707c478bd9Sstevel@tonic-gate if (temp != NULL) 10717c478bd9Sstevel@tonic-gate *temp = '\0'; 10727c478bd9Sstevel@tonic-gate 10737c478bd9Sstevel@tonic-gate r->resp = strdup(respbuf); 10747c478bd9Sstevel@tonic-gate if (r->resp == NULL) { 10757c478bd9Sstevel@tonic-gate freeresponse(num_msg, response); 10767c478bd9Sstevel@tonic-gate return (PAM_BUF_ERR); 10777c478bd9Sstevel@tonic-gate } 10787c478bd9Sstevel@tonic-gate break; 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate case PAM_ERROR_MSG: 10817c478bd9Sstevel@tonic-gate if (m->msg != NULL) { 10827c478bd9Sstevel@tonic-gate (void) fputs(m->msg, stderr); 10837c478bd9Sstevel@tonic-gate (void) fputs("\n", stderr); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate break; 10867c478bd9Sstevel@tonic-gate 10877c478bd9Sstevel@tonic-gate case PAM_TEXT_INFO: 10887c478bd9Sstevel@tonic-gate if (m->msg != NULL) { 10897c478bd9Sstevel@tonic-gate (void) fputs(m->msg, stdout); 10907c478bd9Sstevel@tonic-gate (void) fputs("\n", stdout); 10917c478bd9Sstevel@tonic-gate } 10927c478bd9Sstevel@tonic-gate break; 10937c478bd9Sstevel@tonic-gate 10947c478bd9Sstevel@tonic-gate default: 10957c478bd9Sstevel@tonic-gate break; 10967c478bd9Sstevel@tonic-gate } 10977c478bd9Sstevel@tonic-gate m++; 10987c478bd9Sstevel@tonic-gate r++; 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate return (PAM_SUCCESS); 11017c478bd9Sstevel@tonic-gate } 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate /* 11047c478bd9Sstevel@tonic-gate * emb_su_conv(): 11057c478bd9Sstevel@tonic-gate * This is the conv (conversation) function called from 11067c478bd9Sstevel@tonic-gate * a PAM authentication module to print error messages 11077c478bd9Sstevel@tonic-gate * or garner information from the user. 11087c478bd9Sstevel@tonic-gate * This version is used for embedded_su. 11097c478bd9Sstevel@tonic-gate */ 11107c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 11117c478bd9Sstevel@tonic-gate static int 11127c478bd9Sstevel@tonic-gate emb_su_conv(int num_msg, struct pam_message **msg, 11137c478bd9Sstevel@tonic-gate struct pam_response **response, void *appdata_ptr) 11147c478bd9Sstevel@tonic-gate { 11157c478bd9Sstevel@tonic-gate struct pam_message *m; 11167c478bd9Sstevel@tonic-gate struct pam_response *r; 11177c478bd9Sstevel@tonic-gate char *temp; 11187c478bd9Sstevel@tonic-gate int k; 11197c478bd9Sstevel@tonic-gate char respbuf[PAM_MAX_RESP_SIZE]; 11207c478bd9Sstevel@tonic-gate 11217c478bd9Sstevel@tonic-gate if (num_msg <= 0) 11227c478bd9Sstevel@tonic-gate return (PAM_CONV_ERR); 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate *response = (struct pam_response *)calloc(num_msg, 11257c478bd9Sstevel@tonic-gate sizeof (struct pam_response)); 11267c478bd9Sstevel@tonic-gate if (*response == NULL) 11277c478bd9Sstevel@tonic-gate return (PAM_BUF_ERR); 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate /* First, send the prompts */ 11307c478bd9Sstevel@tonic-gate (void) printf("CONV %d\n", num_msg); 11317c478bd9Sstevel@tonic-gate k = num_msg; 11327c478bd9Sstevel@tonic-gate m = *msg; 11337c478bd9Sstevel@tonic-gate while (k--) { 11347c478bd9Sstevel@tonic-gate switch (m->msg_style) { 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate case PAM_PROMPT_ECHO_OFF: 11377c478bd9Sstevel@tonic-gate (void) puts("PAM_PROMPT_ECHO_OFF"); 11387c478bd9Sstevel@tonic-gate goto msg_common; 11397c478bd9Sstevel@tonic-gate 11407c478bd9Sstevel@tonic-gate case PAM_PROMPT_ECHO_ON: 11417c478bd9Sstevel@tonic-gate (void) puts("PAM_PROMPT_ECHO_ON"); 11427c478bd9Sstevel@tonic-gate goto msg_common; 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate case PAM_ERROR_MSG: 11457c478bd9Sstevel@tonic-gate (void) puts("PAM_ERROR_MSG"); 11467c478bd9Sstevel@tonic-gate goto msg_common; 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate case PAM_TEXT_INFO: 11497c478bd9Sstevel@tonic-gate (void) puts("PAM_TEXT_INFO"); 11507c478bd9Sstevel@tonic-gate /* fall through to msg_common */ 11517c478bd9Sstevel@tonic-gate msg_common: 11527c478bd9Sstevel@tonic-gate if (m->msg == NULL) 11537c478bd9Sstevel@tonic-gate quotemsg(NULL); 11547c478bd9Sstevel@tonic-gate else 11557c478bd9Sstevel@tonic-gate quotemsg("%s", m->msg); 11567c478bd9Sstevel@tonic-gate break; 11577c478bd9Sstevel@tonic-gate 11587c478bd9Sstevel@tonic-gate default: 11597c478bd9Sstevel@tonic-gate break; 11607c478bd9Sstevel@tonic-gate } 11617c478bd9Sstevel@tonic-gate m++; 11627c478bd9Sstevel@tonic-gate } 11637c478bd9Sstevel@tonic-gate 11647c478bd9Sstevel@tonic-gate /* Next, collect the responses */ 11657c478bd9Sstevel@tonic-gate k = num_msg; 11667c478bd9Sstevel@tonic-gate m = *msg; 11677c478bd9Sstevel@tonic-gate r = *response; 11687c478bd9Sstevel@tonic-gate while (k--) { 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate switch (m->msg_style) { 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate case PAM_PROMPT_ECHO_OFF: 11737c478bd9Sstevel@tonic-gate case PAM_PROMPT_ECHO_ON: 11747c478bd9Sstevel@tonic-gate (void) fgets(respbuf, sizeof (respbuf), stdin); 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate temp = strchr(respbuf, '\n'); 11777c478bd9Sstevel@tonic-gate if (temp != NULL) 11787c478bd9Sstevel@tonic-gate *temp = '\0'; 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate r->resp = strdup(respbuf); 11817c478bd9Sstevel@tonic-gate if (r->resp == NULL) { 11827c478bd9Sstevel@tonic-gate freeresponse(num_msg, response); 11837c478bd9Sstevel@tonic-gate return (PAM_BUF_ERR); 11847c478bd9Sstevel@tonic-gate } 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate break; 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate case PAM_ERROR_MSG: 11897c478bd9Sstevel@tonic-gate case PAM_TEXT_INFO: 11907c478bd9Sstevel@tonic-gate break; 11917c478bd9Sstevel@tonic-gate 11927c478bd9Sstevel@tonic-gate default: 11937c478bd9Sstevel@tonic-gate break; 11947c478bd9Sstevel@tonic-gate } 11957c478bd9Sstevel@tonic-gate m++; 11967c478bd9Sstevel@tonic-gate r++; 11977c478bd9Sstevel@tonic-gate } 11987c478bd9Sstevel@tonic-gate return (PAM_SUCCESS); 11997c478bd9Sstevel@tonic-gate } 12007c478bd9Sstevel@tonic-gate 12017c478bd9Sstevel@tonic-gate static void 12027c478bd9Sstevel@tonic-gate freeresponse(int num_msg, struct pam_response **response) 12037c478bd9Sstevel@tonic-gate { 12047c478bd9Sstevel@tonic-gate struct pam_response *r; 12057c478bd9Sstevel@tonic-gate int i; 12067c478bd9Sstevel@tonic-gate 12077c478bd9Sstevel@tonic-gate /* free responses */ 12087c478bd9Sstevel@tonic-gate r = *response; 12097c478bd9Sstevel@tonic-gate for (i = 0; i < num_msg; i++, r++) { 12107c478bd9Sstevel@tonic-gate if (r->resp != NULL) { 12117c478bd9Sstevel@tonic-gate /* Zap it in case it's a password */ 12127c478bd9Sstevel@tonic-gate (void) memset(r->resp, '\0', strlen(r->resp)); 12137c478bd9Sstevel@tonic-gate free(r->resp); 12147c478bd9Sstevel@tonic-gate } 12157c478bd9Sstevel@tonic-gate } 12167c478bd9Sstevel@tonic-gate free(*response); 12177c478bd9Sstevel@tonic-gate *response = NULL; 12187c478bd9Sstevel@tonic-gate } 12197c478bd9Sstevel@tonic-gate 12207c478bd9Sstevel@tonic-gate /* 12217c478bd9Sstevel@tonic-gate * Print a message, applying quoting for lines starting with '.'. 12227c478bd9Sstevel@tonic-gate * 12237c478bd9Sstevel@tonic-gate * I18n note: \n is "safe" in all locales, and all locales use 12247c478bd9Sstevel@tonic-gate * a high-bit-set character to start multibyte sequences, so 12257c478bd9Sstevel@tonic-gate * scanning for a \n followed by a '.' is safe. 12267c478bd9Sstevel@tonic-gate */ 12277c478bd9Sstevel@tonic-gate static void 12287c478bd9Sstevel@tonic-gate quotemsg(char *fmt, ...) 12297c478bd9Sstevel@tonic-gate { 12307c478bd9Sstevel@tonic-gate if (fmt != NULL) { 12317c478bd9Sstevel@tonic-gate char *msg; 12327c478bd9Sstevel@tonic-gate char *p; 12337c478bd9Sstevel@tonic-gate boolean_t bol; 12347c478bd9Sstevel@tonic-gate va_list v; 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate va_start(v, fmt); 12377c478bd9Sstevel@tonic-gate msg = alloc_vsprintf(fmt, v); 12387c478bd9Sstevel@tonic-gate va_end(v); 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate bol = B_TRUE; 12417c478bd9Sstevel@tonic-gate for (p = msg; *p != '\0'; p++) { 12427c478bd9Sstevel@tonic-gate if (bol) { 12437c478bd9Sstevel@tonic-gate if (*p == '.') 12447c478bd9Sstevel@tonic-gate (void) putchar('.'); 12457c478bd9Sstevel@tonic-gate bol = B_FALSE; 12467c478bd9Sstevel@tonic-gate } 12477c478bd9Sstevel@tonic-gate (void) putchar(*p); 12487c478bd9Sstevel@tonic-gate if (*p == '\n') 12497c478bd9Sstevel@tonic-gate bol = B_TRUE; 12507c478bd9Sstevel@tonic-gate } 12517c478bd9Sstevel@tonic-gate (void) putchar('\n'); 12527c478bd9Sstevel@tonic-gate free(msg); 12537c478bd9Sstevel@tonic-gate } 12547c478bd9Sstevel@tonic-gate (void) putchar('.'); 12557c478bd9Sstevel@tonic-gate (void) putchar('\n'); 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate /* 12597c478bd9Sstevel@tonic-gate * validate - Check that the account is valid for switching to. 12607c478bd9Sstevel@tonic-gate */ 12617c478bd9Sstevel@tonic-gate static void 12625435d801Sgww validate(char *usernam, int *pw_change) 12637c478bd9Sstevel@tonic-gate { 12645435d801Sgww int error; 12655435d801Sgww int tries; 12667c478bd9Sstevel@tonic-gate 126757c40785SJoep Vesseur if ((error = pam_acct_mgmt(pamh, pam_flags)) != PAM_SUCCESS) { 12687c478bd9Sstevel@tonic-gate if (Sulog != NULL) 12697c478bd9Sstevel@tonic-gate log(Sulog, pwd.pw_name, 0); /* log entry */ 12707c478bd9Sstevel@tonic-gate if (error == PAM_NEW_AUTHTOK_REQD) { 12715435d801Sgww tries = 0; 12727c478bd9Sstevel@tonic-gate message(ERR, gettext("Password for user " 12735435d801Sgww "'%s' has expired"), pwd.pw_name); 1274f00e6aa6Sdarrenm while ((error = pam_chauthtok(pamh, 1275f00e6aa6Sdarrenm PAM_CHANGE_EXPIRED_AUTHTOK)) != PAM_SUCCESS) { 12765435d801Sgww if ((error == PAM_AUTHTOK_ERR || 12775435d801Sgww error == PAM_TRY_AGAIN) && 12785435d801Sgww (tries++ < DEF_ATTEMPTS)) { 12795435d801Sgww continue; 12805435d801Sgww } 12815435d801Sgww message(ERR, gettext("Sorry")); 128209295472Sgww audit_failure(PW_FAILED, &pwd, NULL, error); 12837c478bd9Sstevel@tonic-gate if (dosyslog) 12845435d801Sgww syslog(LOG_CRIT, 12855435d801Sgww "'su %s' failed for %s on %s", 12867c478bd9Sstevel@tonic-gate pwd.pw_name, usernam, ttyn); 12877c478bd9Sstevel@tonic-gate closelog(); 12887c478bd9Sstevel@tonic-gate exit(1); 12895435d801Sgww } 12905435d801Sgww *pw_change = PW_TRUE; 12915435d801Sgww return; 12927c478bd9Sstevel@tonic-gate } else { 12937c478bd9Sstevel@tonic-gate message(ERR, gettext("Sorry")); 129409295472Sgww audit_failure(PW_FALSE, &pwd, NULL, error); 12957c478bd9Sstevel@tonic-gate if (dosyslog) 12967c478bd9Sstevel@tonic-gate syslog(LOG_CRIT, "'su %s' failed for %s on %s", 12977c478bd9Sstevel@tonic-gate pwd.pw_name, usernam, ttyn); 12987c478bd9Sstevel@tonic-gate closelog(); 12997c478bd9Sstevel@tonic-gate exit(3); 13007c478bd9Sstevel@tonic-gate } 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate static char *illegal[] = { 13057c478bd9Sstevel@tonic-gate "SHELL=", 13067c478bd9Sstevel@tonic-gate "HOME=", 13077c478bd9Sstevel@tonic-gate "LOGNAME=", 13087c478bd9Sstevel@tonic-gate #ifndef NO_MAIL 13097c478bd9Sstevel@tonic-gate "MAIL=", 13107c478bd9Sstevel@tonic-gate #endif 13117c478bd9Sstevel@tonic-gate "CDPATH=", 13127c478bd9Sstevel@tonic-gate "IFS=", 13137c478bd9Sstevel@tonic-gate "PATH=", 13147c478bd9Sstevel@tonic-gate "TZ=", 13157c478bd9Sstevel@tonic-gate "HZ=", 13167c478bd9Sstevel@tonic-gate "TERM=", 13177c478bd9Sstevel@tonic-gate 0 13187c478bd9Sstevel@tonic-gate }; 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate /* 13217c478bd9Sstevel@tonic-gate * legalenvvar - can PAM modules insert this environmental variable? 13227c478bd9Sstevel@tonic-gate */ 13237c478bd9Sstevel@tonic-gate 13247c478bd9Sstevel@tonic-gate static int 13257c478bd9Sstevel@tonic-gate legalenvvar(char *s) 13267c478bd9Sstevel@tonic-gate { 13277c478bd9Sstevel@tonic-gate register char **p; 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate for (p = illegal; *p; p++) 13307c478bd9Sstevel@tonic-gate if (strncmp(s, *p, strlen(*p)) == 0) 13317c478bd9Sstevel@tonic-gate return (0); 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate if (s[0] == 'L' && s[1] == 'D' && s[2] == '_') 13347c478bd9Sstevel@tonic-gate return (0); 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate return (1); 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate 13397c478bd9Sstevel@tonic-gate /* 13407c478bd9Sstevel@tonic-gate * The embedded_su protocol allows the client application to supply 13417c478bd9Sstevel@tonic-gate * an initialization block terminated by a line with just a "." on it. 13427c478bd9Sstevel@tonic-gate * 13437c478bd9Sstevel@tonic-gate * This initialization block is currently unused, reserved for future 13447c478bd9Sstevel@tonic-gate * expansion. Ignore it. This is made very slightly more complex by 13457c478bd9Sstevel@tonic-gate * the desire to cleanly ignore input lines of any length, while still 13467c478bd9Sstevel@tonic-gate * correctly detecting a line with just a "." on it. 13477c478bd9Sstevel@tonic-gate * 13487c478bd9Sstevel@tonic-gate * I18n note: It appears that none of the Solaris-supported locales 13497c478bd9Sstevel@tonic-gate * use 0x0a for any purpose other than newline, so looking for '\n' 13507c478bd9Sstevel@tonic-gate * seems safe. 13517c478bd9Sstevel@tonic-gate * All locales use high-bit-set leadin characters for their multi-byte 13527c478bd9Sstevel@tonic-gate * sequences, so a line consisting solely of ".\n" is what it appears 13537c478bd9Sstevel@tonic-gate * to be. 13547c478bd9Sstevel@tonic-gate */ 13557c478bd9Sstevel@tonic-gate static void 13567c478bd9Sstevel@tonic-gate readinitblock(void) 13577c478bd9Sstevel@tonic-gate { 13587c478bd9Sstevel@tonic-gate char buf[100]; 13597c478bd9Sstevel@tonic-gate boolean_t bol; 13607c478bd9Sstevel@tonic-gate 13617c478bd9Sstevel@tonic-gate bol = B_TRUE; 13627c478bd9Sstevel@tonic-gate for (;;) { 13637c478bd9Sstevel@tonic-gate if (fgets(buf, sizeof (buf), stdin) == NULL) 13647c478bd9Sstevel@tonic-gate return; 13657c478bd9Sstevel@tonic-gate if (bol && strcmp(buf, ".\n") == 0) 13667c478bd9Sstevel@tonic-gate return; 13677c478bd9Sstevel@tonic-gate bol = (strchr(buf, '\n') != NULL); 13687c478bd9Sstevel@tonic-gate } 13697c478bd9Sstevel@tonic-gate } 13705435d801Sgww #else /* !DYNAMIC_SU */ 13715435d801Sgww static void 13725435d801Sgww update_audit(struct passwd *pwd) 13735435d801Sgww { 13745435d801Sgww adt_session_data_t *ah; /* audit session handle */ 13755435d801Sgww 13765435d801Sgww if (adt_start_session(&ah, NULL, ADT_USE_PROC_DATA) != 0) { 13775435d801Sgww message(ERR, gettext("Sorry")); 13785435d801Sgww if (dosyslog) 13795435d801Sgww syslog(LOG_CRIT, "'su %s' failed for %s " 13805435d801Sgww "cannot start audit session %m", 13815435d801Sgww pwd->pw_name, username); 13825435d801Sgww closelog(); 13835435d801Sgww exit(2); 13845435d801Sgww } 13855435d801Sgww if (adt_set_user(ah, pwd->pw_uid, pwd->pw_gid, pwd->pw_uid, 13865435d801Sgww pwd->pw_gid, NULL, ADT_UPDATE) != 0) { 13875435d801Sgww if (dosyslog) 13885435d801Sgww syslog(LOG_CRIT, "'su %s' failed for %s " 13895435d801Sgww "cannot update audit session %m", 13905435d801Sgww pwd->pw_name, username); 13915435d801Sgww closelog(); 13925435d801Sgww exit(2); 13935435d801Sgww } 13945435d801Sgww } 13957c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate /* 13987c478bd9Sstevel@tonic-gate * Report an error, either a fatal one, a warning, or a usage message, 13997c478bd9Sstevel@tonic-gate * depending on the mode parameter. 14007c478bd9Sstevel@tonic-gate */ 14017c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 14027c478bd9Sstevel@tonic-gate static void 14037c478bd9Sstevel@tonic-gate message(enum messagemode mode, char *fmt, ...) 14047c478bd9Sstevel@tonic-gate { 14057c478bd9Sstevel@tonic-gate char *s; 14067c478bd9Sstevel@tonic-gate va_list v; 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate va_start(v, fmt); 14097c478bd9Sstevel@tonic-gate s = alloc_vsprintf(fmt, v); 14107c478bd9Sstevel@tonic-gate va_end(v); 14117c478bd9Sstevel@tonic-gate 14127c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 14137c478bd9Sstevel@tonic-gate if (embedded) { 14147c478bd9Sstevel@tonic-gate if (mode == WARN) { 14157c478bd9Sstevel@tonic-gate (void) printf("CONV 1\n"); 14167c478bd9Sstevel@tonic-gate (void) printf("PAM_ERROR_MSG\n"); 14177c478bd9Sstevel@tonic-gate } else { /* ERR, USAGE */ 14187c478bd9Sstevel@tonic-gate (void) printf("ERROR\n"); 14197c478bd9Sstevel@tonic-gate } 14207c478bd9Sstevel@tonic-gate if (mode == USAGE) { 14217c478bd9Sstevel@tonic-gate quotemsg("%s", s); 14227c478bd9Sstevel@tonic-gate } else { /* ERR, WARN */ 14237c478bd9Sstevel@tonic-gate quotemsg("%s: %s", myname, s); 14247c478bd9Sstevel@tonic-gate } 14257c478bd9Sstevel@tonic-gate } else { 14267c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 14277c478bd9Sstevel@tonic-gate if (mode == USAGE) { 14287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s\n", s); 14297c478bd9Sstevel@tonic-gate } else { /* ERR, WARN */ 14307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: %s\n", myname, s); 14317c478bd9Sstevel@tonic-gate } 14327c478bd9Sstevel@tonic-gate #ifdef DYNAMIC_SU 14337c478bd9Sstevel@tonic-gate } 14347c478bd9Sstevel@tonic-gate #endif /* DYNAMIC_SU */ 14357c478bd9Sstevel@tonic-gate 14367c478bd9Sstevel@tonic-gate free(s); 14377c478bd9Sstevel@tonic-gate } 14387c478bd9Sstevel@tonic-gate 14397c478bd9Sstevel@tonic-gate /* 14407c478bd9Sstevel@tonic-gate * Return a pointer to the last path component of a. 14417c478bd9Sstevel@tonic-gate */ 14427c478bd9Sstevel@tonic-gate static char * 14437c478bd9Sstevel@tonic-gate tail(char *a) 14447c478bd9Sstevel@tonic-gate { 14457c478bd9Sstevel@tonic-gate char *p; 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate p = strrchr(a, '/'); 14487c478bd9Sstevel@tonic-gate if (p == NULL) 14497c478bd9Sstevel@tonic-gate p = a; 14507c478bd9Sstevel@tonic-gate else 14517c478bd9Sstevel@tonic-gate p++; /* step over the '/' */ 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate return (p); 14547c478bd9Sstevel@tonic-gate } 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate static char * 14577c478bd9Sstevel@tonic-gate alloc_vsprintf(const char *fmt, va_list ap1) 14587c478bd9Sstevel@tonic-gate { 14597c478bd9Sstevel@tonic-gate va_list ap2; 14607c478bd9Sstevel@tonic-gate int n; 14617c478bd9Sstevel@tonic-gate char buf[1]; 14627c478bd9Sstevel@tonic-gate char *s; 14637c478bd9Sstevel@tonic-gate 14647c478bd9Sstevel@tonic-gate /* 14657c478bd9Sstevel@tonic-gate * We need to scan the argument list twice. Save off a copy 14667c478bd9Sstevel@tonic-gate * of the argument list pointer(s) for the second pass. Note that 14677c478bd9Sstevel@tonic-gate * we are responsible for va_end'ing our copy. 14687c478bd9Sstevel@tonic-gate */ 14697c478bd9Sstevel@tonic-gate va_copy(ap2, ap1); 14707c478bd9Sstevel@tonic-gate 14717c478bd9Sstevel@tonic-gate /* 14727c478bd9Sstevel@tonic-gate * vsnprintf into a dummy to get a length. One might 14737c478bd9Sstevel@tonic-gate * think that passing 0 as the length to snprintf would 14747c478bd9Sstevel@tonic-gate * do what we want, but it's defined not to. 14757c478bd9Sstevel@tonic-gate * 14767c478bd9Sstevel@tonic-gate * Perhaps we should sprintf into a 100 character buffer 14777c478bd9Sstevel@tonic-gate * or something like that, to avoid two calls to snprintf 14787c478bd9Sstevel@tonic-gate * in most cases. 14797c478bd9Sstevel@tonic-gate */ 14807c478bd9Sstevel@tonic-gate n = vsnprintf(buf, sizeof (buf), fmt, ap2); 14817c478bd9Sstevel@tonic-gate va_end(ap2); 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate /* 14847c478bd9Sstevel@tonic-gate * Allocate an appropriately-sized buffer. 14857c478bd9Sstevel@tonic-gate */ 14867c478bd9Sstevel@tonic-gate s = malloc(n + 1); 14877c478bd9Sstevel@tonic-gate if (s == NULL) { 14887c478bd9Sstevel@tonic-gate perror("malloc"); 14897c478bd9Sstevel@tonic-gate exit(4); 14907c478bd9Sstevel@tonic-gate } 14917c478bd9Sstevel@tonic-gate 14927c478bd9Sstevel@tonic-gate (void) vsnprintf(s, n+1, fmt, ap1); 14937c478bd9Sstevel@tonic-gate 14947c478bd9Sstevel@tonic-gate return (s); 14957c478bd9Sstevel@tonic-gate } 1496