← Back to branch summary

~ubuntu-branches/ubuntu/quantal/sudo/quantal

« back to all changes in this revision

Viewing changes to aix.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2011-11-20 12:07:45 UTC
  • mfrom: (1.3.17 sid)
  • Revision ID: package-import@ubuntu.com-20111120120745-o3qpklobmygytndc
Tags: 1.8.3p1-1ubuntu1
* Merge from debian/testing, remaining changes:
  - debian/patches/keep_home_by_default.patch:
    + Set HOME in initial_keepenv_table. (rebased for 1.8.3p1)
  - debian/patches/enable_badpass.patch: turn on "mail_badpass" by default:
    + attempting sudo without knowing a login password is as bad as not
      being listed in the sudoers file, especially if getting the password
      wrong means doing the access-check-email-notification never happens
      (rebased for 1.8.3p1)
  - debian/rules:
    + compile with --without-lecture --with-tty-tickets (Ubuntu specific)
    + install man/man8/sudo_root.8 (Ubuntu specific)
    + install apport hooks
    + The ubuntu-sudo-as-admin-successful.patch was taken upstream by
      Debian however it requires a --enable-admin-flag configure flag to
      actually enable it.
  - debian/sudoers: 
    + grant admin group sudo access
  - debian/sudo-ldap.dirs, debian/sudo.dirs: 
    + add usr/share/apport/package-hooks
  - debian/sudo.preinst:
    + avoid conffile prompt by checking for known default /etc/sudoers
      and if found installing the correct default /etc/sudoers file

Show diffs side-by-side

added added

removed removed

Lines of Context:
aix.c
1
 
/*
2
 
 * Copyright (c) 2008, 2010 Todd C. Miller <Todd.Miller@courtesan.com>
3
 
 *
4
 
 * Permission to use, copy, modify, and distribute this software for any
5
 
 * purpose with or without fee is hereby granted, provided that the above
6
 
 * copyright notice and this permission notice appear in all copies.
7
 
 *
8
 
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
 
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
 
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
 
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
 
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
 
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
 
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
 
 */
16
 
 
17
 
#include <config.h>
18
 
 
19
 
#include <sys/types.h>
20
 
#include <sys/resource.h>
21
 
 
22
 
#include <stdio.h>
23
 
#ifdef STDC_HEADERS
24
 
# include <stdlib.h>
25
 
# include <stddef.h>
26
 
#else
27
 
# ifdef HAVE_STDLIB_H
28
 
#  include <stdlib.h>
29
 
# endif
30
 
#endif /* STDC_HEADERS */
31
 
#include <usersec.h>
32
 
#include <uinfo.h>
33
 
 
34
 
#include "compat.h"
35
 
#include "alloc.h"
36
 
#include "error.h"
37
 
 
38
 
#ifdef HAVE_GETUSERATTR
39
 
 
40
 
#ifndef HAVE_SETRLIMIT64
41
 
# define setrlimit64(a, b) setrlimit(a, b)
42
 
# define rlimit64 rlimit
43
 
# define rlim64_t rlim_t
44
 
# define RLIM64_INFINITY RLIM_INFINITY
45
 
#endif /* HAVE_SETRLIMIT64 */
46
 
 
47
 
#ifndef RLIM_SAVED_MAX
48
 
# define RLIM_SAVED_MAX RLIM64_INFINITY
49
 
#endif
50
 
 
51
 
struct aix_limit {
52
 
    int resource;
53
 
    char *soft;
54
 
    char *hard;
55
 
    int factor;
56
 
};
57
 
 
58
 
static struct aix_limit aix_limits[] = {
59
 
    { RLIMIT_FSIZE, S_UFSIZE, S_UFSIZE_HARD, 512 },
60
 
    { RLIMIT_CPU, S_UCPU, S_UCPU_HARD, 1 },
61
 
    { RLIMIT_DATA, S_UDATA, S_UDATA_HARD, 512 },
62
 
    { RLIMIT_STACK, S_USTACK, S_USTACK_HARD, 512 },
63
 
    { RLIMIT_RSS, S_URSS, S_URSS_HARD, 512 },
64
 
    { RLIMIT_CORE, S_UCORE, S_UCORE_HARD, 512 },
65
 
    { RLIMIT_NOFILE, S_UNOFILE, S_UNOFILE_HARD, 1 }
66
 
};
67
 
 
68
 
static int
69
 
aix_getlimit(user, lim, valp)
70
 
    char *user;
71
 
    char *lim;
72
 
    rlim64_t *valp;
73
 
{
74
 
    int val;
75
 
 
76
 
    if (getuserattr(user, lim, &val, SEC_INT) != 0 &&
77
 
        getuserattr("default", lim, &val, SEC_INT) != 0) {
78
 
        return(-1);
79
 
    }
80
 
    *valp = val;
81
 
    return(0);
82
 
}
83
 
 
84
 
static void
85
 
aix_setlimits(user)
86
 
    char *user;
87
 
{
88
 
    struct rlimit64 rlim;
89
 
    rlim64_t val;
90
 
    int n;
91
 
 
92
 
    if (setuserdb(S_READ) != 0)
93
 
        error(1, "unable to open userdb");
94
 
 
95
 
    /*
96
 
     * For each resource limit, get the soft/hard values for the user
97
 
     * and set those values via setrlimit64().  Must be run as euid 0.
98
 
     */
99
 
    for (n = 0; n < sizeof(aix_limits) / sizeof(aix_limits[0]); n++) {
100
 
        /*
101
 
         * We have two strategies, depending on whether or not the
102
 
         * hard limit has been defined.
103
 
         */
104
 
        if (aix_getlimit(user, aix_limits[n].hard, &val) == 0) {
105
 
            rlim.rlim_max = val == -1 ? RLIM64_INFINITY : val * aix_limits[n].factor;
106
 
            if (aix_getlimit(user, aix_limits[n].soft, &val) == 0)
107
 
                rlim.rlim_cur = val == -1 ? RLIM64_INFINITY : val * aix_limits[n].factor;
108
 
            else
109
 
                rlim.rlim_cur = rlim.rlim_max;  /* soft not specd, use hard */
110
 
        } else {
111
 
            /* No hard limit set, try soft limit. */
112
 
            if (aix_getlimit(user, aix_limits[n].soft, &val) == 0)
113
 
                rlim.rlim_cur = val == -1 ? RLIM64_INFINITY : val * aix_limits[n].factor;
114
 
 
115
 
            /* Set hard limit per AIX /etc/security/limits documentation. */
116
 
            switch (aix_limits[n].resource) {
117
 
                case RLIMIT_CPU:
118
 
                case RLIMIT_FSIZE:
119
 
                    rlim.rlim_max = rlim.rlim_cur;
120
 
                    break;
121
 
                case RLIMIT_STACK:
122
 
                    rlim.rlim_max = RLIM_SAVED_MAX;
123
 
                    break;
124
 
                default:
125
 
                    rlim.rlim_max = RLIM64_INFINITY;
126
 
                    break;
127
 
            }
128
 
        }
129
 
        (void)setrlimit64(aix_limits[n].resource, &rlim);
130
 
    }
131
 
    enduserdb();
132
 
}
133
 
 
134
 
#ifdef HAVE_SETAUTHDB
135
 
/*
136
 
 * Look up administrative domain for user (SYSTEM in /etc/security/user) and
137
 
 * set it as the default for the process.  This ensures that password and
138
 
 * group lookups are made against the correct source (files, NIS, LDAP, etc).
139
 
 */
140
 
void
141
 
aix_setauthdb(user)
142
 
    char *user;
143
 
{
144
 
    char *registry;
145
 
 
146
 
    if (user != NULL) {
147
 
        if (setuserdb(S_READ) != 0)
148
 
            error(1, "unable to open userdb");
149
 
        if (getuserattr(user, S_REGISTRY, &registry, SEC_CHAR) == 0) {
150
 
            if (setauthdb(registry, NULL) != 0)
151
 
                error(1, "unable to switch to registry \"%s\" for %s",
152
 
                    registry, user);
153
 
        }
154
 
        enduserdb();
155
 
    }
156
 
}
157
 
 
158
 
/*
159
 
 * Restore the saved administrative domain, if any.
160
 
 */
161
 
void
162
 
aix_restoreauthdb()
163
 
{
164
 
    if (setauthdb(NULL, NULL) != 0)
165
 
        error(1, "unable to restore registry");
166
 
}
167
 
#endif
168
 
 
169
 
void
170
 
aix_prep_user(user, tty)
171
 
    char *user;
172
 
    char *tty;
173
 
{
174
 
    char *info;
175
 
    int len;
176
 
 
177
 
    /* set usrinfo, like login(1) does */
178
 
    len = easprintf(&info, "NAME=%s%cLOGIN=%s%cLOGNAME=%s%cTTY=%s%c",
179
 
        user, '\0', user, '\0', user, '\0', tty ? tty : "", '\0');
180
 
    (void)usrinfo(SETUINFO, info, len);
181
 
    efree(info);
182
 
 
183
 
#ifdef HAVE_SETAUTHDB
184
 
    /* set administrative domain */
185
 
    aix_setauthdb(user);
186
 
#endif
187
 
 
188
 
    /* set resource limits */
189
 
    aix_setlimits(user);
190
 
}
191
 
#endif /* HAVE_GETUSERATTR */