diff --git a/lib/libutil/login.conf.5 b/lib/libutil/login.conf.5 index b4c96f298767..863aa0616908 100644 --- a/lib/libutil/login.conf.5 +++ b/lib/libutil/login.conf.5 @@ -1,449 +1,458 @@ .\" Copyright (c) 1996 David Nugent .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, is permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice immediately at the beginning of the file, without modification, .\" this list of conditions, and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" 3. This work was done expressly for inclusion into FreeBSD. Other use .\" is permitted provided this notation is included. .\" 4. Absolutely no warranty of function or purpose is made by the author .\" David Nugent. .\" 5. Modifications may be freely made to this file providing the above .\" conditions are met. .\" .\" $FreeBSD$ .\" .Dd October 9, 2006 .Dt LOGIN.CONF 5 .Os .Sh NAME .Nm login.conf .Nd login class capability database .Sh SYNOPSIS .Pa /etc/login.conf , .Pa ~/.login_conf .Sh DESCRIPTION .Nm contains various attributes and capabilities of login classes. A login class (an optional annotation against each record in the user account database, .Pa /etc/master.passwd ) determines session accounting, resource limits and user environment settings. It is used by various programs in the system to set up a user's login environment and to enforce policy, accounting and administrative restrictions. It also provides the means by which users are able to be authenticated to the system and the types of authentication available. Attributes in addition to the ones described here are available with third-party packages. .Pp A special record "default" in the system user class capability database .Pa /etc/login.conf is used automatically for any non-root user without a valid login class in .Pa /etc/master.passwd . A user with a uid of 0 without a valid login class will use the record "root" if it exists, or "default" if not. .Pp In .Fx , users may individually create a file called .Pa .login_conf in their home directory using the same format, consisting of a single entry with a record id of "me". If present, this file is used by .Xr login 1 to set user-defined environment settings which override those specified in the system login capabilities database. Only a subset of login capabilities may be overridden, typically those which do not involve authentication, resource limits and accounting. .Pp Records in a class capabilities database consist of a number of colon-separated fields. The first entry for each record gives one or more names that a record is to be known by, each separated by a '|' character. The first name is the most common abbreviation. The last name given should be a long name that is more descriptive of the capability entry, and all others are synonyms. All names but the last should be in lower case and contain no blanks; the last name may contain upper case characters and blanks for readability. .Pp Note that since a colon .Pq Ql :\& is used to separate capability entries, a .Ql \ec escape sequence must be used to embed a literal colon in the value or name of a capability. .Pp The default .Pa /etc/login.conf shipped with .Fx is an out of the box configuration. Whenever changes to this, or the user's .Pa ~/.login_conf , file are made, the modifications will not be picked up until .Xr cap_mkdb 1 is used to compile the file into a database. This database file will have a .Pa .db extension and is accessed through .Xr cgetent 3 . See .Xr getcap 3 for a more in-depth description of the format of a capability database. .Sh CAPABILITIES Fields within each record in the database follow the .Xr getcap 3 conventions for boolean, type string .Ql \&= and type numeric .Ql \&# , although type numeric is deprecated in favour of the string format and either form is accepted for a numeric datum. Values fall into the following categories: .Bl -tag -width "program" .It bool If the name is present, then the boolean value is true; otherwise, it is false .It file Path name to a data file .It program Path name to an executable file .It list A list of values (or pairs of values) separated by commas or spaces .It path A space or comma separated list of path names, following the usual csh conventions (leading tilde with and without username being expanded to home directories etc.) .It number A numeric value, either decimal (default), hexadecimal (with leading 0x), or octal (with a leading 0). With a numeric type, only one numeric value is allowed. Numeric types may also be specified in string format (i.e., the capability tag being delimited from the value by '=' instead of '#'). Whichever method is used, then all records in the database must use the same method to allow values to be correctly overridden in interpolated records. .It size A number which expresses a size. The default interpretation of a value is the number of bytes, but a suffix may specify alternate units: .Bl -tag -offset indent -compact -width xxxx .It b explicitly selects 512-byte blocks .It k selects kilobytes (1024 bytes) .It m specifies a multiplier of 1 megabyte (1048576 bytes), .It g specifies units of gigabytes, and .It t represents terabytes. .El A size value is a numeric quantity and case of the suffix is not significant. Concatenated values are added together. .It time A period of time, by default in seconds. A prefix may specify a different unit: .Bl -tag -offset indent -compact -width xxxx .It y indicates the number of 365 day years, .It w indicates the number of weeks, .It d the number of days, .It h the number of hours, .It m the number of minutes, and .It s the number of seconds. .El Concatenated values are added together. For example, 2 hours and 40 minutes may be written either as 9600s, 160m or 2h40m. .El .Pp The usual convention to interpolate capability entries using the special .Em tc=value notation may be used. .Sh RESOURCE LIMITS .Bl -column coredumpsize indent indent .It Sy "Name Type Notes Description .It "coredumpsize size Maximum coredump size limit. .It "cputime time CPU usage limit. .It "datasize size Maximum data size limit. .It "filesize size Maximum file size limit. .It "maxproc number Maximum number of processes. .It "memorylocked size Maximum locked in core memory size limit. .It "memoryuse size Maximum of core memory use size limit. .It "openfiles number Maximum number of open files per process. .It "sbsize size Maximum permitted socketbuffer size. .It "vmemoryuse size Maximum permitted total VM usage per process. .It "stacksize size Maximum stack size limit. .El .Pp These resource limit entries actually specify both the maximum and current limits (see .Xr getrlimit 2 ) . The current (soft) limit is the one normally used, although the user is permitted to increase the current limit to the maximum (hard) limit. The maximum and current limits may be specified individually by appending a -max or -cur to the capability name. .Sh ENVIRONMENT .Bl -column ignorenologin indent xbinxxusrxbin .It Sy "Name Type Notes Description .It "charset string Set $MM_CHARSET environment variable to the specified value. +.It "cpumask string List of cpus to bind the user to. +The syntax is the same as for the +.Fl l +argument of +.Xr cpuset 1 or the word +.Ql default . +If set to +.Ql default +no action is taken. .It "hushlogin bool false Same as having a ~/.hushlogin file. .It "ignorenologin bool false Login not prevented by nologin. .It "ftp-chroot bool false Limit FTP access with .Xr chroot 2 to the .Ev HOME directory of the user. See .Xr ftpd 8 for details. .It "label string Default MAC policy; see .Xr maclabel 7 . .It "lang string Set $LANG environment variable to the specified value. .It "manpath path Default search path for manpages. .It "nocheckmail bool false Display mail status at login. .It "nologin file If the file exists it will be displayed and the login session will be terminated. .It "path path /bin /usr/bin Default search path. .It "priority number Initial priority (nice) level. .It "requirehome bool false Require a valid home directory to login. .It "setenv list A comma-separated list of environment variables and values to which they are to be set. .It "shell prog Session shell to execute rather than the shell specified in the passwd file. The SHELL environment variable will contain the shell specified in the password file. .It "term string Default terminal type if not able to determine from other means. .It "timezone string Default value of $TZ environment variable. .It "umask number 022 Initial umask. Should always have a leading 0 to ensure octal interpretation. .It "welcome file /etc/motd File containing welcome message. .El .Sh AUTHENTICATION .Bl -column passwd_prompt indent indent .It Sy "Name Type Notes Description .\" .It "approve program Program to approve login. .It "copyright file File containing additional copyright information .It "host.allow list List of remote host wildcards from which users in the class may access. .It "host.deny list List of remote host wildcards from which users in the class may not access. .It "login_prompt string The login prompt given by .Xr login 1 .It "login-backoff number 3 The number of login attempts allowed before the backoff delay is inserted after each subsequent attempt. The backoff delay is the number of tries above .Em login-backoff multiplied by 5 seconds. .It "login-retries number 10 The number of login attempts allowed before the login fails. .It "passwd_format string md5 The encryption format that new or changed passwords will use. Valid values include "des", "md5" and "blf". NIS clients using a .No non- Ns Fx NIS server should probably use "des". .It "passwd_prompt string The password prompt presented by .Xr login 1 .It "times.allow list List of time periods during which logins are allowed. .It "times.deny list List of time periods during which logins are disallowed. .It "ttys.allow list List of ttys and ttygroups which users in the class may use for access. .It "ttys.deny list List of ttys and ttygroups which users in the class may not use for access. .It "warnexpire time Advance notice for pending account expiry. .It "warnpassword time Advance notice for pending password expiry. .\".It "widepasswords bool false Use the wide password format. The wide password .\" format allows up to 128 significant characters in the password. .El .Pp These fields are intended to be used by .Xr passwd 1 and other programs in the login authentication system. .Pp Capabilities that set environment variables are scanned for both .Ql \&~ and .Ql \&$ characters, which are substituted for a user's home directory and name respectively. To pass these characters literally into the environment variable, escape the character by preceding it with a backslash '\\'. .Pp The .Em host.allow and .Em host.deny entries are comma separated lists used for checking remote access to the system, and consist of a list of hostnames and/or IP addresses against which remote network logins are checked. Items in these lists may contain wildcards in the form used by shell programs for wildcard matching (See .Xr fnmatch 3 for details on the implementation). The check on hosts is made against both the remote system's Internet address and hostname (if available). If both lists are empty or not specified, then logins from any remote host are allowed. If host.allow contains one or more hosts, then only remote systems matching any of the items in that list are allowed to log in. If host.deny contains one or more hosts, then a login from any matching hosts will be disallowed. .Pp The .Em times.allow and .Em times.deny entries consist of a comma-separated list of time periods during which the users in a class are allowed to be logged in. These are expressed as one or more day codes followed by a start and end times expressed in 24 hour format, separated by a hyphen or dash. For example, MoThSa0200-1300 translates to Monday, Thursday and Saturday between the hours of 2 am and 1 p.m.. If both of these time lists are empty, users in the class are allowed access at any time. If .Em times.allow is specified, then logins are only allowed during the periods given. If .Em times.deny is specified, then logins are denied during the periods given, regardless of whether one of the periods specified in .Em times.allow applies. .Pp Note that .Xr login 1 enforces only that the actual login falls within periods allowed by these entries. Further enforcement over the life of a session requires a separate daemon to monitor transitions from an allowed period to a non-allowed one. .Pp The .Em ttys.allow and .Em ttys.deny entries contain a comma-separated list of tty devices (without the /dev/ prefix) that a user in a class may use to access the system, and/or a list of ttygroups (See .Xr getttyent 3 and .Xr ttys 5 for information on ttygroups). If neither entry exists, then the choice of login device used by the user is unrestricted. If only .Em ttys.allow is specified, then the user is restricted only to ttys in the given group or device list. If only .Em ttys.deny is specified, then the user is prevented from using the specified devices or devices in the group. If both lists are given and are non-empty, the user is restricted to those devices allowed by ttys.allow that are not available by ttys.deny. .Pp The .Em minpasswordlen and .Em minpasswordcase facilities for enforcing restrictions on password quality, which used to be supported by .Nm , have been superseded by the .Xr pam_passwdqc 8 PAM module. .Sh RESERVED CAPABILITIES The following capabilities are reserved for the purposes indicated and may be supported by third-party software. They are not implemented in the base system. .Bl -column host.accounted indent indent .It Sy "Name Type Notes Description .It "accounted bool false Enable session time accounting for all users in this class. .It "auth list passwd Allowed authentication styles. The first item is the default style. .It "auth-" Ns Ar type Ta "list Allowed authentication styles for the authentication .Ar type . .It "autodelete time Time after expiry when account is auto-deleted. .It "bootfull bool false Enable 'boot only if ttygroup is full' strategy when terminating sessions. .It "daytime time Maximum login time per day. .It "expireperiod time Time for expiry allocation. .It "graceexpire time Grace days for expired account. .It "gracetime time Additional grace login time allowed. .It "host.accounted list List of remote host wildcards from which login sessions will be accounted. .It "host.exempt list List of remote host wildcards from which login session accounting is exempted. .It "idletime time Maximum idle time before logout. .It "minpasswordlen number 6 The minimum length a local password may be. .It "mixpasswordcase bool true Whether .Xr passwd 1 will warn the user if an all lower case password is entered. .It "monthtime time Maximum login time per month. .It "passwordtime time Used by .Xr passwd 1 to set next password expiry date. .It "refreshtime time New time allowed on account refresh. .It "refreshperiod str How often account time is refreshed. .It "sessiontime time Maximum login time per session. .It "sessionlimit number Maximum number of concurrent login sessions on ttys in any group. .It "ttys.accounted list List of ttys and ttygroups for which login accounting is active. .It "ttys.exempt list List of ttys and ttygroups for which login accounting is exempt. .It "warntime time Advance notice for pending out-of-time. .It "weektime time Maximum login time per week. .El .Pp The .Em ttys.accounted and .Em ttys.exempt fields operate in a similar manner to .Em ttys.allow and .Em ttys.deny as explained above. Similarly with the .Em host.accounted and .Em host.exempt lists. .Sh SEE ALSO .Xr cap_mkdb 1 , .Xr login 1 , .Xr chroot 2 , .Xr getcap 3 , .Xr getttyent 3 , .Xr login_cap 3 , .Xr login_class 3 , .Xr pam 3 , .Xr passwd 5 , .Xr ttys 5 , .Xr ftpd 8 , .Xr pam_passwdqc 8 diff --git a/lib/libutil/login_cap.h b/lib/libutil/login_cap.h index a7cb4c67e8f0..c98e7fd0b473 100644 --- a/lib/libutil/login_cap.h +++ b/lib/libutil/login_cap.h @@ -1,158 +1,159 @@ /*- * Copyright (c) 1996 by * Sean Eric Fagan * David Nugent * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, is permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice immediately at the beginning of the file, without modification, * this list of conditions, and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. This work was done expressly for inclusion into FreeBSD. Other use * is permitted provided this notation is included. * 4. Absolutely no warranty of function or purpose is made by the authors. * 5. Modifications may be freely made to this file providing the above * conditions are met. * * Low-level routines relating to the user capabilities database * * Was login_cap.h,v 1.9 1997/05/07 20:00:01 eivind Exp * $FreeBSD$ */ #ifndef _LOGIN_CAP_H_ #define _LOGIN_CAP_H_ #define LOGIN_DEFCLASS "default" #define LOGIN_DEFROOTCLASS "root" #define LOGIN_MECLASS "me" #define LOGIN_DEFSTYLE "passwd" #define LOGIN_DEFSERVICE "login" #define LOGIN_DEFUMASK 022 #define LOGIN_DEFPRI 0 #define _PATH_LOGIN_CONF "/etc/login.conf" #define _FILE_LOGIN_CONF ".login_conf" #define _PATH_AUTHPROG "/usr/libexec/login_" #define LOGIN_SETGROUP 0x0001 /* set group */ #define LOGIN_SETLOGIN 0x0002 /* set login (via setlogin) */ #define LOGIN_SETPATH 0x0004 /* set path */ #define LOGIN_SETPRIORITY 0x0008 /* set priority */ #define LOGIN_SETRESOURCES 0x0010 /* set resources (cputime, etc.) */ #define LOGIN_SETUMASK 0x0020 /* set umask, obviously */ #define LOGIN_SETUSER 0x0040 /* set user (via setuid) */ #define LOGIN_SETENV 0x0080 /* set user environment */ #define LOGIN_SETMAC 0x0100 /* set user default MAC label */ -#define LOGIN_SETALL 0x01ff /* set everything */ +#define LOGIN_SETCPUMASK 0x0200 /* set user cpumask */ +#define LOGIN_SETALL 0x03ff /* set everything */ #define BI_AUTH "authorize" /* accepted authentication */ #define BI_REJECT "reject" /* rejected authentication */ #define BI_CHALLENG "reject challenge" /* reject with a challenge */ #define BI_SILENT "reject silent" /* reject silently */ #define BI_REMOVE "remove" /* remove file on error */ #define BI_ROOTOKAY "authorize root" /* root authenticated */ #define BI_SECURE "authorize secure" /* okay on non-secure line */ #define BI_SETENV "setenv" /* set environment variable */ #define BI_VALUE "value" /* set local variable */ #define AUTH_OKAY 0x01 /* user authenticated */ #define AUTH_ROOTOKAY 0x02 /* root login okay */ #define AUTH_SECURE 0x04 /* secure login */ #define AUTH_SILENT 0x08 /* silent rejection */ #define AUTH_CHALLENGE 0x10 /* a chellenge was given */ #define AUTH_ALLOW (AUTH_OKAY | AUTH_ROOTOKAY | AUTH_SECURE) typedef struct login_cap { char *lc_class; char *lc_cap; char *lc_style; } login_cap_t; typedef struct login_time { u_short lt_start; /* Start time */ u_short lt_end; /* End time */ #define LTM_NONE 0x00 #define LTM_SUN 0x01 #define LTM_MON 0x02 #define LTM_TUE 0x04 #define LTM_WED 0x08 #define LTM_THU 0x10 #define LTM_FRI 0x20 #define LTM_SAT 0x40 #define LTM_ANY 0x7F #define LTM_WK 0x3E #define LTM_WD 0x41 u_char lt_dow; /* Days of week */ } login_time_t; #define LC_MAXTIMES 64 #include __BEGIN_DECLS struct passwd; void login_close(login_cap_t *); login_cap_t *login_getclassbyname(const char *, const struct passwd *); login_cap_t *login_getclass(const char *); login_cap_t *login_getpwclass(const struct passwd *); login_cap_t *login_getuserclass(const struct passwd *); const char *login_getcapstr(login_cap_t*, const char *, const char *, const char *); const char **login_getcaplist(login_cap_t *, const char *, const char *); const char *login_getstyle(login_cap_t *, const char *, const char *); rlim_t login_getcaptime(login_cap_t *, const char *, rlim_t, rlim_t); rlim_t login_getcapnum(login_cap_t *, const char *, rlim_t, rlim_t); rlim_t login_getcapsize(login_cap_t *, const char *, rlim_t, rlim_t); const char *login_getpath(login_cap_t *, const char *, const char *); int login_getcapbool(login_cap_t *, const char *, int); const char *login_setcryptfmt(login_cap_t *, const char *, const char *); int setclasscontext(const char*, unsigned int); int setusercontext(login_cap_t*, const struct passwd*, uid_t, unsigned int); void setclassresources(login_cap_t *); void setclassenvironment(login_cap_t *, const struct passwd *, int); /* Most of these functions are deprecated */ int auth_approve(login_cap_t*, const char*, const char*); int auth_check(const char *, const char *, const char *, const char *, int *); void auth_env(void); char *auth_mkvalue(const char *n); int auth_response(const char *, const char *, const char *, const char *, int *, const char *, const char *); void auth_rmfiles(void); int auth_scan(int); int auth_script(const char*, ...); int auth_script_data(const char *, int, const char *, ...); char *auth_valud(const char *); int auth_setopt(const char *, const char *); void auth_clropts(void); void auth_checknologin(login_cap_t*); int auth_cat(const char*); int auth_ttyok(login_cap_t*, const char *); int auth_hostok(login_cap_t*, const char *, char const *); int auth_timeok(login_cap_t*, time_t); struct tm; login_time_t parse_lt(const char *); int in_ltm(const login_time_t *, struct tm *, time_t *); int in_ltms(const login_time_t *, struct tm *, time_t *); /* helper functions */ int login_strinlist(const char **, char const *, int); int login_str2inlist(const char **, const char *, const char *, int); login_time_t * login_timelist(login_cap_t *, char const *, int *, login_time_t **); int login_ttyok(login_cap_t *, const char *, const char *, const char *); int login_hostok(login_cap_t *, const char *, const char *, const char *, const char *); __END_DECLS #endif /* _LOGIN_CAP_H_ */ diff --git a/lib/libutil/login_class.3 b/lib/libutil/login_class.3 index ca5b2cebf972..c91f9a9ef68e 100644 --- a/lib/libutil/login_class.3 +++ b/lib/libutil/login_class.3 @@ -1,197 +1,211 @@ .\" Copyright (c) 1995 David Nugent .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, is permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice immediately at the beginning of the file, without modification, .\" this list of conditions, and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" 3. This work was done expressly for inclusion into FreeBSD. Other use .\" is permitted provided this notation is included. .\" 4. Absolutely no warranty of function or purpose is made by the author .\" David Nugent. .\" 5. Modifications may be freely made to this file providing the above .\" conditions are met. .\" .\" $FreeBSD$ .\" .Dd December 28, 1996 .Os .Dt LOGIN_CLASS 3 .Sh NAME .Nm setclasscontext , .Nm setclassenvironment , .Nm setclassresources , .Nm setusercontext .Nd "functions for using the login class capabilities database" .Sh LIBRARY .Lb libutil .Sh SYNOPSIS .In sys/types.h .In login_cap.h .Ft int .Fn setclasscontext "const char *classname" "unsigned int flags" .Ft int .Fn setusercontext "login_cap_t *lc" "const struct passwd *pwd" "uid_t uid" "unsigned int flags" .Ft void .Fn setclassresources "login_cap_t *lc" .Ft void .Fn setclassenvironment "login_cap_t *lc" "const struct passwd *pwd" "int paths" .Sh DESCRIPTION These functions provide a higher level interface to the login class database than those documented in .Xr login_cap 3 . These functions are used to set resource limits, environment and accounting settings for users on logging into the system and when selecting an appropriate set of environment and resource settings for system daemons based on login classes. These functions may only be called if the current process is running with root privileges. If the LOGIN_SETLOGIN flag is used this function calls .Xr setlogin 2 , and due care must be taken as detailed in the manpage for that function and this affects all processes running in the same session and not just the current process. .Pp The .Fn setclasscontext function sets various class context values (resource limits, umask and process priorities) based on values for a specific named class. .Pp The .Fn setusercontext function sets class context values based on a given login_cap_t object and a specific passwd record (if login_cap_t is NULL), the current session's login, and the current process user and group ownership. Each of these actions is selectable via bit-flags passed in the .Ar flags parameter, which is comprised of one or more of the following: .Bl -tag -width LOGIN_SETRESOURCES .It LOGIN_SETLOGIN Set the login associated with the current session to the user specified in the passwd structure using .Xr setlogin 2 . The .Ar pwd parameter must not be NULL if this option is used. .It LOGIN_SETUSER Set ownership of the current process to the uid specified in the .Ar uid parameter using .Xr setuid 2 . .It LOGIN_SETGROUP Set group ownership of the current process to the group id specified in the passwd structure using .Xr setgid 2 , and calls .Xr initgroups 3 to set up the group access list for the current process. The .Ar pwd parameter must not be NULL if this option is used. .It LOGIN_SETRESOURCES Set resource limits for the current process based on values specified in the system login class database. Class capability tags used, with and without -cur (soft limit) or -max (hard limit) suffixes and the corresponding resource setting: .Bd -literal cputime RLIMIT_CPU filesize RLIMIT_FSIZE datasize RLIMIT_DATA stacksize RLIMIT_STACK coredumpsize RLIMIT_CORE memoryuse RLIMIT_RSS memorylocked RLIMIT_MEMLOCK maxproc RLIMIT_NPROC openfiles RLIMIT_NOFILE sbsize RLIMIT_SBSIZE vmemoryuse RLIMIT_VMEM .Ed .It LOGIN_SETPRIORITY Set the scheduling priority for the current process based on the value specified in the system login class database. Class capability tags used: .Bd -literal priority .Ed .It LOGIN_SETUMASK Set the umask for the current process to a value in the user or system login class database. Class capability tags used: .Bd -literal umask .Ed .It LOGIN_SETPATH Set the "path" and "manpath" environment variables based on values in the user or system login class database. Class capability tags used with the corresponding environment variables set: .Bd -literal path PATH manpath MANPATH .Ed .It LOGIN_SETENV Set various environment variables based on values in the user or system login class database. Class capability tags used with the corresponding environment variables set: .Bd -literal lang LANG charset MM_CHARSET timezone TZ term TERM .Ed .Pp Additional environment variables may be set using the list type capability "setenv=var1 val1,var2 val2..,varN valN". .It LOGIN_SETMAC Set the MAC label for the current process to the label specified in system login class database. .Pp +.It LOGIN_SETCPUMASK +Create a new +.Xr cpuset 2 +and set the cpu affinity to the specified mask. +The string may contain a comma separated list of numbers and/or number +ranges as handled by the +.Xr cpuset 1 +utility or the case-insensitive string +.Ql default . +If the string is +.Ql default +no action will be taken. .It LOGIN_SETALL Enables all of the above settings. .El .Pp Note that when setting environment variables and a valid passwd pointer is provided in the .Ar pwd parameter, the characters .Ql \&~ and .Ql \&$ are substituted for the user's home directory and login name respectively. .Pp The .Fn setclassresources and .Fn setclassenvironment functions are subsets of the setcontext functions above, but may be useful in isolation. .Sh RETURN VALUES The .Fn setclasscontext and .Fn setusercontext functions return -1 if an error occurred, or 0 on success. If an error occurs when attempting to set the user, login, group or resources, a message is reported to .Xr syslog 3 , with LOG_ERR priority and directed to the currently active facility. .Sh SEE ALSO +.Xr cpuset 1 , +.Xr cpuset 2 , .Xr setgid 2 , .Xr setlogin 2 , .Xr setuid 2 , .Xr getcap 3 , .Xr initgroups 3 , .Xr login_cap 3 , .Xr mac_set_proc 3 , .Xr login.conf 5 , .Xr termcap 5 diff --git a/lib/libutil/login_class.c b/lib/libutil/login_class.c index 39f114f2d49f..c18d46af9878 100644 --- a/lib/libutil/login_class.c +++ b/lib/libutil/login_class.c @@ -1,429 +1,536 @@ /*- * Copyright (c) 1996 by * Sean Eric Fagan * David Nugent * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, is permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice immediately at the beginning of the file, without modification, * this list of conditions, and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. This work was done expressly for inclusion into FreeBSD. Other use * is permitted provided this notation is included. * 4. Absolutely no warranty of function or purpose is made by the authors. * 5. Modifications may be freely made to this file providing the above * conditions are met. * * High-level routines relating to use of the user capabilities database */ #include __FBSDID("$FreeBSD$"); #include +#include #include #include #include +#include #include #include #include #include #include #include #include #include #include #include #include #include static struct login_res { const char *what; rlim_t (*who)(login_cap_t *, const char *, rlim_t, rlim_t); int why; } resources[] = { { "cputime", login_getcaptime, RLIMIT_CPU }, { "filesize", login_getcapsize, RLIMIT_FSIZE }, { "datasize", login_getcapsize, RLIMIT_DATA }, { "stacksize", login_getcapsize, RLIMIT_STACK }, { "memoryuse", login_getcapsize, RLIMIT_RSS }, { "memorylocked", login_getcapsize, RLIMIT_MEMLOCK }, { "maxproc", login_getcapnum, RLIMIT_NPROC }, { "openfiles", login_getcapnum, RLIMIT_NOFILE }, { "coredumpsize", login_getcapsize, RLIMIT_CORE }, { "sbsize", login_getcapsize, RLIMIT_SBSIZE }, { "vmemoryuse", login_getcapsize, RLIMIT_VMEM }, { NULL, 0, 0 } }; void setclassresources(login_cap_t *lc) { struct login_res *lr; if (lc == NULL) return; for (lr = resources; lr->what != NULL; ++lr) { struct rlimit rlim; /* * The login.conf file can have , -max, and * -cur entries. * What we do is get the current current- and maximum- limits. * Then, we try to get an entry for from the capability, * using the current and max limits we just got as the * default/error values. * *Then*, we try looking for -cur and -max, * again using the appropriate values as the default/error * conditions. */ if (getrlimit(lr->why, &rlim) != 0) syslog(LOG_ERR, "getting %s resource limit: %m", lr->what); else { char name_cur[40]; char name_max[40]; rlim_t rcur = rlim.rlim_cur; rlim_t rmax = rlim.rlim_max; sprintf(name_cur, "%s-cur", lr->what); sprintf(name_max, "%s-max", lr->what); rcur = (*lr->who)(lc, lr->what, rcur, rcur); rmax = (*lr->who)(lc, lr->what, rmax, rmax); rlim.rlim_cur = (*lr->who)(lc, name_cur, rcur, rcur); rlim.rlim_max = (*lr->who)(lc, name_max, rmax, rmax); if (setrlimit(lr->why, &rlim) == -1) syslog(LOG_WARNING, "set class '%s' resource limit %s: %m", lc->lc_class, lr->what); } } } static struct login_vars { const char *tag; const char *var; const char *def; int overwrite; } pathvars[] = { { "path", "PATH", NULL, 1}, { "cdpath", "CDPATH", NULL, 1}, { "manpath", "MANPATH", NULL, 1}, { NULL, NULL, NULL, 0} }, envars[] = { { "lang", "LANG", NULL, 1}, { "charset", "MM_CHARSET", NULL, 1}, { "timezone", "TZ", NULL, 1}, { "term", "TERM", NULL, 0}, { NULL, NULL, NULL, 0} }; static char * substvar(const char * var, const struct passwd * pwd, int hlen, int pch, int nlen) { char *np = NULL; if (var != NULL) { int tildes = 0; int dollas = 0; char *p; if (pwd != NULL) { /* Count the number of ~'s in var to substitute */ for (p = (char *)var; (p = strchr(p, '~')) != NULL; p++) ++tildes; /* Count the number of $'s in var to substitute */ for (p = (char *)var; (p = strchr(p, '$')) != NULL; p++) ++dollas; } np = malloc(strlen(var) + (dollas * nlen) - dollas + (tildes * (pch+hlen)) - tildes + 1); if (np != NULL) { p = strcpy(np, var); if (pwd != NULL) { /* * This loop does user username and homedir substitutions * for unescaped $ (username) and ~ (homedir) */ while (*(p += strcspn(p, "~$")) != '\0') { int l = strlen(p); if (p > np && *(p-1) == '\\') /* Escaped: */ memmove(p - 1, p, l + 1); /* Slide-out the backslash */ else if (*p == '~') { int v = pch && *(p+1) != '/'; /* Avoid double // */ memmove(p + hlen + v, p + 1, l); /* Subst homedir */ memmove(p, pwd->pw_dir, hlen); if (v) p[hlen] = '/'; p += hlen + v; } else /* if (*p == '$') */ { memmove(p + nlen, p + 1, l); /* Subst username */ memmove(p, pwd->pw_name, nlen); p += nlen; } } } } } return np; } void setclassenvironment(login_cap_t *lc, const struct passwd * pwd, int paths) { struct login_vars *vars = paths ? pathvars : envars; int hlen = pwd ? strlen(pwd->pw_dir) : 0; int nlen = pwd ? strlen(pwd->pw_name) : 0; char pch = 0; if (hlen && pwd->pw_dir[hlen-1] != '/') ++pch; while (vars->tag != NULL) { const char * var = paths ? login_getpath(lc, vars->tag, NULL) : login_getcapstr(lc, vars->tag, NULL, NULL); char * np = substvar(var, pwd, hlen, pch, nlen); if (np != NULL) { setenv(vars->var, np, vars->overwrite); free(np); } else if (vars->def != NULL) { setenv(vars->var, vars->def, 0); } ++vars; } /* * If we're not processing paths, then see if there is a setenv list by * which the admin and/or user may set an arbitrary set of env vars. */ if (!paths) { const char **set_env = login_getcaplist(lc, "setenv", ","); if (set_env != NULL) { while (*set_env != NULL) { char *p = strchr(*set_env, '='); if (p != NULL) { /* Discard invalid entries */ char *np; *p++ = '\0'; if ((np = substvar(p, pwd, hlen, pch, nlen)) != NULL) { setenv(*set_env, np, 1); free(np); } } ++set_env; } } } } +static int +list2cpuset(const char *list, cpuset_t *mask) +{ + enum { NONE, NUM, DASH } state; + int lastnum; + int curnum; + const char *l; + + state = NONE; + curnum = lastnum = 0; + for (l = list; *l != '\0';) { + if (isdigit(*l)) { + curnum = atoi(l); + if (curnum > CPU_SETSIZE) + errx(EXIT_FAILURE, + "Only %d cpus supported", CPU_SETSIZE); + while (isdigit(*l)) + l++; + switch (state) { + case NONE: + lastnum = curnum; + state = NUM; + break; + case DASH: + for (; lastnum <= curnum; lastnum++) + CPU_SET(lastnum, mask); + state = NONE; + break; + case NUM: + default: + return (0); + } + continue; + } + switch (*l) { + case ',': + switch (state) { + case NONE: + break; + case NUM: + CPU_SET(curnum, mask); + state = NONE; + break; + case DASH: + return (0); + break; + } + break; + case '-': + if (state != NUM) + return (0); + state = DASH; + break; + default: + return (0); + } + l++; + } + switch (state) { + case NONE: + break; + case NUM: + CPU_SET(curnum, mask); + break; + case DASH: + return (0); + } + return 1; +} + + +void +setclasscpumask(login_cap_t *lc) +{ + const char *maskstr; + cpuset_t maskset; + cpusetid_t setid; + + maskstr = login_getcapstr(lc, "cpumask", NULL, NULL); + CPU_ZERO(&maskset); + if (maskstr == NULL) + return; + if (strcasecmp("default", maskstr) == 0) + return; + if (!list2cpuset(maskstr, &maskset)) { + syslog(LOG_WARNING, + "list2cpuset(%s) invalid mask specification", maskstr); + return; + } + + if (cpuset(&setid) != 0) { + syslog(LOG_ERR, "cpuset(): %s", strerror(errno)); + return; + } + + if (cpuset_setaffinity(CPU_LEVEL_CPUSET, CPU_WHICH_PID, -1, + sizeof(maskset), &maskset) != 0) + syslog(LOG_ERR, "cpuset_setaffinity(%s): %s", maskstr, + strerror(errno)); +} + + /* * setclasscontext() * * For the login class , set various class context values * (limits, mainly) to the values for that class. Which values are * set are controlled by -- see for the * possible values. * * setclasscontext() can only set resources, priority, and umask. */ int setclasscontext(const char *classname, unsigned int flags) { int rc; login_cap_t *lc; lc = login_getclassbyname(classname, NULL); flags &= LOGIN_SETRESOURCES | LOGIN_SETPRIORITY | LOGIN_SETUMASK | LOGIN_SETPATH; rc = lc ? setusercontext(lc, NULL, 0, flags) : -1; login_close(lc); return rc; } /* * Private function which takes care of processing */ static mode_t setlogincontext(login_cap_t *lc, const struct passwd *pwd, mode_t mymask, unsigned long flags) { if (lc) { /* Set resources */ if (flags & LOGIN_SETRESOURCES) setclassresources(lc); /* See if there's a umask override */ if (flags & LOGIN_SETUMASK) mymask = (mode_t)login_getcapnum(lc, "umask", mymask, mymask); /* Set paths */ if (flags & LOGIN_SETPATH) setclassenvironment(lc, pwd, 1); /* Set environment */ if (flags & LOGIN_SETENV) setclassenvironment(lc, pwd, 0); + /* Set cpu affinity */ + if (flags & LOGIN_SETCPUMASK) + setclasscpumask(lc); } return mymask; } /* * setusercontext() * * Given a login class and a user in , with a uid , * set the context as in setclasscontext(). controls which * values are set. * * The difference between setclasscontext() and setusercontext() is * that the former sets things up for an already-existing process, * while the latter sets things up from a root context. Such as might * be called from login(1). * */ int setusercontext(login_cap_t *lc, const struct passwd *pwd, uid_t uid, unsigned int flags) { quad_t p; mode_t mymask; login_cap_t *llc = NULL; struct rtprio rtp; int error; if (lc == NULL) { if (pwd != NULL && (lc = login_getpwclass(pwd)) != NULL) llc = lc; /* free this when we're done */ } if (flags & LOGIN_SETPATH) pathvars[0].def = uid ? _PATH_DEFPATH : _PATH_STDPATH; /* we need a passwd entry to set these */ if (pwd == NULL) flags &= ~(LOGIN_SETGROUP | LOGIN_SETLOGIN | LOGIN_SETMAC); /* Set the process priority */ if (flags & LOGIN_SETPRIORITY) { p = login_getcapnum(lc, "priority", LOGIN_DEFPRI, LOGIN_DEFPRI); if (p > PRIO_MAX) { rtp.type = RTP_PRIO_IDLE; rtp.prio = p - PRIO_MAX - 1; p = (rtp.prio > RTP_PRIO_MAX) ? 31 : p; if (rtprio(RTP_SET, 0, &rtp)) syslog(LOG_WARNING, "rtprio '%s' (%s): %m", pwd->pw_name, lc ? lc->lc_class : LOGIN_DEFCLASS); } else if (p < PRIO_MIN) { rtp.type = RTP_PRIO_REALTIME; rtp.prio = abs(p - PRIO_MIN + RTP_PRIO_MAX); p = (rtp.prio > RTP_PRIO_MAX) ? 1 : p; if (rtprio(RTP_SET, 0, &rtp)) syslog(LOG_WARNING, "rtprio '%s' (%s): %m", pwd->pw_name, lc ? lc->lc_class : LOGIN_DEFCLASS); } else { if (setpriority(PRIO_PROCESS, 0, (int)p) != 0) syslog(LOG_WARNING, "setpriority '%s' (%s): %m", pwd->pw_name, lc ? lc->lc_class : LOGIN_DEFCLASS); } } /* Setup the user's group permissions */ if (flags & LOGIN_SETGROUP) { if (setgid(pwd->pw_gid) != 0) { syslog(LOG_ERR, "setgid(%lu): %m", (u_long)pwd->pw_gid); login_close(llc); return -1; } if (initgroups(pwd->pw_name, pwd->pw_gid) == -1) { syslog(LOG_ERR, "initgroups(%s,%lu): %m", pwd->pw_name, (u_long)pwd->pw_gid); login_close(llc); return -1; } } /* Set up the user's MAC label. */ if ((flags & LOGIN_SETMAC) && mac_is_present(NULL) == 1) { const char *label_string; mac_t label; label_string = login_getcapstr(lc, "label", NULL, NULL); if (label_string != NULL) { if (mac_from_text(&label, label_string) == -1) { syslog(LOG_ERR, "mac_from_text('%s') for %s: %m", pwd->pw_name, label_string); return -1; } if (mac_set_proc(label) == -1) error = errno; else error = 0; mac_free(label); if (error != 0) { syslog(LOG_ERR, "mac_set_proc('%s') for %s: %s", label_string, pwd->pw_name, strerror(error)); return -1; } } } /* Set the sessions login */ if ((flags & LOGIN_SETLOGIN) && setlogin(pwd->pw_name) != 0) { syslog(LOG_ERR, "setlogin(%s): %m", pwd->pw_name); login_close(llc); return -1; } mymask = (flags & LOGIN_SETUMASK) ? umask(LOGIN_DEFUMASK) : 0; mymask = setlogincontext(lc, pwd, mymask, flags); login_close(llc); /* This needs to be done after anything that needs root privs */ if ((flags & LOGIN_SETUSER) && setuid(uid) != 0) { syslog(LOG_ERR, "setuid(%lu): %m", (u_long)uid); return -1; /* Paranoia again */ } /* * Now, we repeat some of the above for the user's private entries */ if ((lc = login_getuserclass(pwd)) != NULL) { mymask = setlogincontext(lc, pwd, mymask, flags); login_close(lc); } /* Finally, set any umask we've found */ if (flags & LOGIN_SETUMASK) umask(mymask); return 0; }