[gssapi-openssh.git] / openssh / openbsd-compat / port-aix.c

#include "includes.h"

#ifdef _AIX

#ifdef HAVE_USERSEC_H
#include <usersec.h>
#endif /* HAVE_USERSEC_H */

#include <uinfo.h>
#include <../xmalloc.h>

/* AIX limits */
#if defined(HAVE_GETUSERATTR) && !defined(S_UFSIZE_HARD) && defined(S_UFSIZE)
# define S_UFSIZE_HARD  S_UFSIZE "_hard"
# define S_UCPU_HARD  S_UCPU "_hard"
# define S_UDATA_HARD  S_UDATA "_hard"
# define S_USTACK_HARD  S_USTACK "_hard"
# define S_URSS_HARD  S_URSS "_hard"
# define S_UCORE_HARD  S_UCORE "_hard"
# define S_UNOFILE_HARD S_UNOFILE "_hard"
#endif

#if defined(HAVE_GETUSERATTR)
/*
 * AIX-specific login initialisation
 */
void 
set_limit(char *user, char *soft, char *hard, int resource, int mult)
{
        struct rlimit rlim;
        int slim, hlim;

        getrlimit(resource, &rlim);

        slim = 0;
        if (getuserattr(user, soft, &slim, SEC_INT) != -1) {
                if (slim < 0) {
                        rlim.rlim_cur = RLIM_INFINITY;
                } else if (slim != 0) {
                        /* See the wackiness below */
                        if (rlim.rlim_cur == slim * mult)
                                slim = 0;
                        else
                                rlim.rlim_cur = slim * mult;
                }
        }
        hlim = 0;
        if (getuserattr(user, hard, &hlim, SEC_INT) != -1) {
                if (hlim < 0) {
                        rlim.rlim_max = RLIM_INFINITY;
                } else if (hlim != 0) {
                        rlim.rlim_max = hlim * mult;
                }
        }

        /*
         * XXX For cpu and fsize the soft limit is set to the hard limit
         * if the hard limit is left at its default value and the soft limit
         * is changed from its default value, either by requesting it
         * (slim == 0) or by setting it to the current default.  At least
         * that's how rlogind does it.  If you're confused you're not alone.
         * Bug or feature? AIX 4.3.1.2
         */
        if ((!strcmp(soft, "fsize") || !strcmp(soft, "cpu"))
            && hlim == 0 && slim != 0)
                rlim.rlim_max = rlim.rlim_cur;
        /* A specified hard limit limits the soft limit */
        else if (hlim > 0 && rlim.rlim_cur > rlim.rlim_max)
                rlim.rlim_cur = rlim.rlim_max;
        /* A soft limit can increase a hard limit */
        else if (rlim.rlim_cur > rlim.rlim_max)
                rlim.rlim_max = rlim.rlim_cur;

        if (setrlimit(resource, &rlim) != 0)
                error("setrlimit(%.10s) failed: %.100s", soft, strerror(errno));
}

void 
set_limits_from_userattr(char *user)
{
        int mask;
        char buf[16];

        set_limit(user, S_UFSIZE, S_UFSIZE_HARD, RLIMIT_FSIZE, 512);
        set_limit(user, S_UCPU, S_UCPU_HARD, RLIMIT_CPU, 1);
        set_limit(user, S_UDATA, S_UDATA_HARD, RLIMIT_DATA, 512);
        set_limit(user, S_USTACK, S_USTACK_HARD, RLIMIT_STACK, 512);
        set_limit(user, S_URSS, S_URSS_HARD, RLIMIT_RSS, 512);
        set_limit(user, S_UCORE, S_UCORE_HARD, RLIMIT_CORE, 512);
#if defined(S_UNOFILE)
        set_limit(user, S_UNOFILE, S_UNOFILE_HARD, RLIMIT_NOFILE, 1);
#endif

        if (getuserattr(user, S_UMASK, &mask, SEC_INT) != -1) {
                /* Convert decimal to octal */
                (void) snprintf(buf, sizeof(buf), "%d", mask);
                if (sscanf(buf, "%o", &mask) == 1)
                        umask(mask);
        }
}
#endif /* defined(HAVE_GETUSERATTR) */

/*
 * AIX has a "usrinfo" area where logname and
 * other stuff is stored - a few applications
 * actually use this and die if it's not set
 */
void
aix_usrinfo(struct passwd *pw, char *tty, int ttyfd) 
{
	u_int i;
	char *cp=NULL;

	if (ttyfd == -1)
		tty[0] = '\0';
	cp = xmalloc(22 + strlen(tty) + 2 * strlen(pw->pw_name));
	i = sprintf(cp, "LOGNAME=%s%cNAME=%s%cTTY=%s%c%c", pw->pw_name, 0, 
	    pw->pw_name, 0, tty, 0, 0);
	if (usrinfo(SETUINFO, cp, i) == -1)
		fatal("Couldn't set usrinfo: %s", strerror(errno));
	debug3("AIX/UsrInfo: set len %d", i);
	xfree(cp);
}

#endif /* _AIX */
Commit	Line	Data
e9a17296	1	#include "includes.h"
	2
	3	#ifdef _AIX
	4
	5	#ifdef HAVE_USERSEC_H
	6	#include <usersec.h>
	7	#endif /* HAVE_USERSEC_H */
	8
	9	#include <uinfo.h>
	10	#include <../xmalloc.h>
	11
	12	/* AIX limits */
	13	#if defined(HAVE_GETUSERATTR) && !defined(S_UFSIZE_HARD) && defined(S_UFSIZE)
	14	# define S_UFSIZE_HARD S_UFSIZE "_hard"
	15	# define S_UCPU_HARD S_UCPU "_hard"
	16	# define S_UDATA_HARD S_UDATA "_hard"
	17	# define S_USTACK_HARD S_USTACK "_hard"
	18	# define S_URSS_HARD S_URSS "_hard"
	19	# define S_UCORE_HARD S_UCORE "_hard"
	20	# define S_UNOFILE_HARD S_UNOFILE "_hard"
	21	#endif
	22
	23	#if defined(HAVE_GETUSERATTR)
	24	/*
	25	* AIX-specific login initialisation
	26	*/
	27	void
	28	set_limit(char user, char soft, char *hard, int resource, int mult)
	29	{
	30	struct rlimit rlim;
	31	int slim, hlim;
	32
	33	getrlimit(resource, &rlim);
	34
	35	slim = 0;
	36	if (getuserattr(user, soft, &slim, SEC_INT) != -1) {
	37	if (slim < 0) {
	38	rlim.rlim_cur = RLIM_INFINITY;
	39	} else if (slim != 0) {
	40	/* See the wackiness below */
	41	if (rlim.rlim_cur == slim * mult)
	42	slim = 0;
	43	else
	44	rlim.rlim_cur = slim * mult;
	45	}
	46	}
	47	hlim = 0;
	48	if (getuserattr(user, hard, &hlim, SEC_INT) != -1) {
	49	if (hlim < 0) {
	50	rlim.rlim_max = RLIM_INFINITY;
	51	} else if (hlim != 0) {
	52	rlim.rlim_max = hlim * mult;
	53	}
	54	}
	55
	56	/*
	57	* XXX For cpu and fsize the soft limit is set to the hard limit
	58	* if the hard limit is left at its default value and the soft limit
	59	* is changed from its default value, either by requesting it
	60	* (slim == 0) or by setting it to the current default. At least
	61	* that's how rlogind does it. If you're confused you're not alone.
	62	* Bug or feature? AIX 4.3.1.2
	63	*/
	64	if ((!strcmp(soft, "fsize") \|\| !strcmp(soft, "cpu"))
65	&& hlim == 0 && slim != 0)
66	rlim.rlim_max = rlim.rlim_cur;
67	/* A specified hard limit limits the soft limit */
68	else if (hlim > 0 && rlim.rlim_cur > rlim.rlim_max)
69	rlim.rlim_cur = rlim.rlim_max;
70	/* A soft limit can increase a hard limit */
71	else if (rlim.rlim_cur > rlim.rlim_max)
72	rlim.rlim_max = rlim.rlim_cur;
73
74	if (setrlimit(resource, &rlim) != 0)
75	error("setrlimit(%.10s) failed: %.100s", soft, strerror(errno));
76	}
77
78	void
79	set_limits_from_userattr(char *user)
80	{
81	int mask;
82	char buf[16];
83
84	set_limit(user, S_UFSIZE, S_UFSIZE_HARD, RLIMIT_FSIZE, 512);
85	set_limit(user, S_UCPU, S_UCPU_HARD, RLIMIT_CPU, 1);
86	set_limit(user, S_UDATA, S_UDATA_HARD, RLIMIT_DATA, 512);
87	set_limit(user, S_USTACK, S_USTACK_HARD, RLIMIT_STACK, 512);
88	set_limit(user, S_URSS, S_URSS_HARD, RLIMIT_RSS, 512);
89	set_limit(user, S_UCORE, S_UCORE_HARD, RLIMIT_CORE, 512);
90	#if defined(S_UNOFILE)
91	set_limit(user, S_UNOFILE, S_UNOFILE_HARD, RLIMIT_NOFILE, 1);
92	#endif
93
94	if (getuserattr(user, S_UMASK, &mask, SEC_INT) != -1) {
95	/* Convert decimal to octal */
96	(void) snprintf(buf, sizeof(buf), "%d", mask);
97	if (sscanf(buf, "%o", &mask) == 1)
98	umask(mask);
99	}
100	}
101	#endif /* defined(HAVE_GETUSERATTR) */
102
103	/*
104	* AIX has a "usrinfo" area where logname and
105	* other stuff is stored - a few applications
106	* actually use this and die if it's not set
107	*/
108	void
109	aix_usrinfo(struct passwd pw, char tty, int ttyfd)
110	{
111	u_int i;
112	char *cp=NULL;
113
114	if (ttyfd == -1)
115	tty[0] = '\0';
116	cp = xmalloc(22 + strlen(tty) + 2 * strlen(pw->pw_name));
117	i = sprintf(cp, "LOGNAME=%s%cNAME=%s%cTTY=%s%c%c", pw->pw_name, 0,
118	pw->pw_name, 0, tty, 0, 0);
119	if (usrinfo(SETUINFO, cp, i) == -1)
120	fatal("Couldn't set usrinfo: %s", strerror(errno));
121	debug3("AIX/UsrInfo: set len %d", i);
122	xfree(cp);
123	}
124
125	#endif /* _AIX */
126