xref: /freebsd/lib/libutil/login_cap.c (revision 56c0434453eef215dd1bff2f1b5796f5f7c95dfa)
168bbf3adSDavid Nugent /*-
268bbf3adSDavid Nugent  * Copyright (c) 1996 by
368bbf3adSDavid Nugent  * Sean Eric Fagan <sef@kithrup.com>
468bbf3adSDavid Nugent  * David Nugent <davidn@blaze.net.au>
568bbf3adSDavid Nugent  * All rights reserved.
668bbf3adSDavid Nugent  *
756c04344SDavid Nugent  * Portions copyright (c) 1995,1997
856c04344SDavid Nugent  * Berkeley Software Design, Inc.
956c04344SDavid Nugent  * All rights reserved.
1056c04344SDavid Nugent  *
1168bbf3adSDavid Nugent  * Redistribution and use in source and binary forms, with or without
1268bbf3adSDavid Nugent  * modification, is permitted provided that the following conditions
1368bbf3adSDavid Nugent  * are met:
1468bbf3adSDavid Nugent  * 1. Redistributions of source code must retain the above copyright
1568bbf3adSDavid Nugent  *    notice immediately at the beginning of the file, without modification,
1668bbf3adSDavid Nugent  *    this list of conditions, and the following disclaimer.
1768bbf3adSDavid Nugent  * 2. Redistributions in binary form must reproduce the above copyright
1868bbf3adSDavid Nugent  *    notice, this list of conditions and the following disclaimer in the
1968bbf3adSDavid Nugent  *    documentation and/or other materials provided with the distribution.
2068bbf3adSDavid Nugent  * 3. This work was done expressly for inclusion into FreeBSD.  Other use
2168bbf3adSDavid Nugent  *    is permitted provided this notation is included.
2268bbf3adSDavid Nugent  * 4. Absolutely no warranty of function or purpose is made by the authors.
2368bbf3adSDavid Nugent  * 5. Modifications may be freely made to this file providing the above
2468bbf3adSDavid Nugent  *    conditions are met.
2568bbf3adSDavid Nugent  *
2668bbf3adSDavid Nugent  * Low-level routines relating to the user capabilities database
2768bbf3adSDavid Nugent  *
2856c04344SDavid Nugent  *	$Id: login_cap.c,v 1.11 1997/02/27 00:24:05 ache Exp $
2968bbf3adSDavid Nugent  */
3068bbf3adSDavid Nugent 
3168bbf3adSDavid Nugent #include <stdio.h>
3268bbf3adSDavid Nugent #include <stdlib.h>
3368bbf3adSDavid Nugent #include <string.h>
3468bbf3adSDavid Nugent #include <errno.h>
3556c04344SDavid Nugent #include <fcntl.h>
3668bbf3adSDavid Nugent #include <unistd.h>
3768bbf3adSDavid Nugent 
3868bbf3adSDavid Nugent #include <sys/types.h>
3968bbf3adSDavid Nugent #include <sys/time.h>
4068bbf3adSDavid Nugent #include <sys/resource.h>
4168bbf3adSDavid Nugent #include <sys/param.h>
4268bbf3adSDavid Nugent #include <pwd.h>
4356c04344SDavid Nugent #include <libutil.h>
4456c04344SDavid Nugent #include <syslog.h>
4568bbf3adSDavid Nugent #include <login_cap.h>
4668bbf3adSDavid Nugent 
4756c04344SDavid Nugent /*
4856c04344SDavid Nugent  * allocstr()
4956c04344SDavid Nugent  * Manage a single static pointer for handling a local char* buffer,
5056c04344SDavid Nugent  * resizing as necessary to contain the string.
5156c04344SDavid Nugent  *
5256c04344SDavid Nugent  * allocarray()
5356c04344SDavid Nugent  * Manage a static array for handling a group of strings, resizing
5456c04344SDavid Nugent  * when necessary.
5556c04344SDavid Nugent  */
5668bbf3adSDavid Nugent 
5768bbf3adSDavid Nugent static int lc_object_count = 0;
5868bbf3adSDavid Nugent 
5968bbf3adSDavid Nugent static size_t internal_stringsz = 0;
6068bbf3adSDavid Nugent static char * internal_string = NULL;
6168bbf3adSDavid Nugent static size_t internal_arraysz = 0;
6268bbf3adSDavid Nugent static char ** internal_array = NULL;
6368bbf3adSDavid Nugent 
6468bbf3adSDavid Nugent static char *
6568bbf3adSDavid Nugent allocstr(char *str)
6668bbf3adSDavid Nugent {
6768bbf3adSDavid Nugent     char    *p;
6856c04344SDavid Nugent 
6968bbf3adSDavid Nugent     size_t sz = strlen(str) + 1;	/* realloc() only if necessary */
7068bbf3adSDavid Nugent     if (sz <= internal_stringsz)
711c594de5SDavid Nugent 	p = strcpy(internal_string, str);
7268bbf3adSDavid Nugent     else if ((p = realloc(internal_string, sz)) != NULL) {
7368bbf3adSDavid Nugent 	internal_stringsz = sz;
7468bbf3adSDavid Nugent 	internal_string = strcpy(p, str);
7568bbf3adSDavid Nugent     }
7668bbf3adSDavid Nugent     return p;
7768bbf3adSDavid Nugent }
7868bbf3adSDavid Nugent 
7956c04344SDavid Nugent 
8068bbf3adSDavid Nugent static char **
8168bbf3adSDavid Nugent allocarray(size_t sz)
8268bbf3adSDavid Nugent {
8368bbf3adSDavid Nugent     char    **p;
8456c04344SDavid Nugent 
8568bbf3adSDavid Nugent     if (sz <= internal_arraysz)
8668bbf3adSDavid Nugent 	p = internal_array;
8768bbf3adSDavid Nugent     else if ((p = realloc(internal_array, sz * sizeof(char*))) != NULL) {
8868bbf3adSDavid Nugent 	internal_arraysz = sz;
8968bbf3adSDavid Nugent 	internal_array = p;
9068bbf3adSDavid Nugent     }
9168bbf3adSDavid Nugent     return p;
9268bbf3adSDavid Nugent }
9368bbf3adSDavid Nugent 
9468bbf3adSDavid Nugent 
9568bbf3adSDavid Nugent /*
9668bbf3adSDavid Nugent  * arrayize()
9768bbf3adSDavid Nugent  * Turn a simple string <str> seperated by any of
9868bbf3adSDavid Nugent  * the set of <chars> into an array.  The last element
9968bbf3adSDavid Nugent  * of the array will be NULL, as is proper.
10068bbf3adSDavid Nugent  * Free using freearraystr()
10168bbf3adSDavid Nugent  */
10268bbf3adSDavid Nugent 
10368bbf3adSDavid Nugent static char **
10468bbf3adSDavid Nugent arrayize(char *str, const char *chars, int *size)
10568bbf3adSDavid Nugent {
10668bbf3adSDavid Nugent     int	    i;
10768bbf3adSDavid Nugent     char    *ptr;
10868bbf3adSDavid Nugent     char    **res = NULL;
10968bbf3adSDavid Nugent 
11056c04344SDavid Nugent     /* count the sub-strings */
11168bbf3adSDavid Nugent     for (i = 0, ptr = str; *ptr; i++) {
11268bbf3adSDavid Nugent 	int count = strcspn(ptr, chars);
1131c594de5SDavid Nugent 	ptr += count;
1141c594de5SDavid Nugent 	if (*ptr)
1151c594de5SDavid Nugent 	    ++ptr;
11668bbf3adSDavid Nugent     }
11768bbf3adSDavid Nugent 
11868bbf3adSDavid Nugent     i = 0;
11956c04344SDavid Nugent     /* alloc the array */
12056c04344SDavid Nugent     if ((ptr = allocstr(str)) != NULL) {
12156c04344SDavid Nugent 	if ((res = allocarray(++i)) == NULL)
12268bbf3adSDavid Nugent 	    free(str);
12356c04344SDavid Nugent 	else {
12456c04344SDavid Nugent 	    /* now split the string */
12556c04344SDavid Nugent 	    while (*ptr) {
12668bbf3adSDavid Nugent 		int count = strcspn(ptr, chars);
12756c04344SDavid Nugent 		res[i++] = ptr;
12868bbf3adSDavid Nugent 		ptr += count;
12968bbf3adSDavid Nugent 		if (*ptr)
13068bbf3adSDavid Nugent 		    *ptr++ = '\0';
13168bbf3adSDavid Nugent 	    }
13256c04344SDavid Nugent 	    res[i] = NULL;
13368bbf3adSDavid Nugent 	}
13456c04344SDavid Nugent     }
13556c04344SDavid Nugent 
13668bbf3adSDavid Nugent     if (size)
13768bbf3adSDavid Nugent 	*size = i;
13856c04344SDavid Nugent 
13968bbf3adSDavid Nugent     return res;
14068bbf3adSDavid Nugent }
14168bbf3adSDavid Nugent 
14256c04344SDavid Nugent 
14368bbf3adSDavid Nugent /*
14468bbf3adSDavid Nugent  * login_close()
14568bbf3adSDavid Nugent  * Frees up all resources relating to a login class
14668bbf3adSDavid Nugent  *
14768bbf3adSDavid Nugent  */
14868bbf3adSDavid Nugent 
14968bbf3adSDavid Nugent void
15068bbf3adSDavid Nugent login_close(login_cap_t * lc)
15168bbf3adSDavid Nugent {
15268bbf3adSDavid Nugent     if (lc) {
15368bbf3adSDavid Nugent 	free(lc->lc_style);
15468bbf3adSDavid Nugent 	free(lc->lc_class);
15568bbf3adSDavid Nugent 	free(lc);
15668bbf3adSDavid Nugent 	if (--lc_object_count == 0) {
15768bbf3adSDavid Nugent 	    free(internal_string);
1582955fda4SDavid Nugent 	    free(internal_array);
15968bbf3adSDavid Nugent 	    internal_array = NULL;
16051706563SDavid Nugent 	    internal_arraysz = 0;
16168bbf3adSDavid Nugent 	    internal_string = NULL;
16251706563SDavid Nugent 	    internal_stringsz = 0;
16368bbf3adSDavid Nugent 	    cgetclose();
16468bbf3adSDavid Nugent 	}
16568bbf3adSDavid Nugent     }
16668bbf3adSDavid Nugent }
16768bbf3adSDavid Nugent 
16868bbf3adSDavid Nugent 
16968bbf3adSDavid Nugent /*
17068bbf3adSDavid Nugent  * login_getclassbyname() get the login class by its name.
17168bbf3adSDavid Nugent  * If the name given is NULL or empty, the default class
17268bbf3adSDavid Nugent  * LOGIN_DEFCLASS (ie. "default") is fetched. If the
17368bbf3adSDavid Nugent  * 'dir' argument contains a non-NULL non-empty string,
17468bbf3adSDavid Nugent  * then the file _FILE_LOGIN_CONF is picked up from that
17568bbf3adSDavid Nugent  * directory instead of the system login database.
17668bbf3adSDavid Nugent  * Return a filled-out login_cap_t structure, including
17768bbf3adSDavid Nugent  * class name, and the capability record buffer.
17868bbf3adSDavid Nugent  */
17968bbf3adSDavid Nugent 
18068bbf3adSDavid Nugent login_cap_t *
18156c04344SDavid Nugent login_getclassbyname(char const *name, const struct passwd *pwd)
18268bbf3adSDavid Nugent {
18356c04344SDavid Nugent     login_cap_t	*lc;
18468bbf3adSDavid Nugent 
18556c04344SDavid Nugent     if ((lc = malloc(sizeof(login_cap_t))) != NULL) {
18656c04344SDavid Nugent 	int	    r, i = 0;
18756c04344SDavid Nugent 	const char  *msg = NULL;
18856c04344SDavid Nugent 	const char  *dir = (pwd == NULL) ? NULL : pwd->pw_dir;
18968bbf3adSDavid Nugent 	char	    userpath[MAXPATHLEN];
19056c04344SDavid Nugent 
19168bbf3adSDavid Nugent 	static char *login_dbarray[] = { NULL, NULL, NULL };
19268bbf3adSDavid Nugent 
19356c04344SDavid Nugent 	if (dir && snprintf(userpath, MAXPATHLEN, "%s/%s", dir,
19456c04344SDavid Nugent 			    _FILE_LOGIN_CONF) < MAXPATHLEN) {
19556c04344SDavid Nugent 	    login_dbarray[i] = userpath;
19656c04344SDavid Nugent 	    if (_secure_path(userpath, pwd->pw_uid, pwd->pw_gid) != -1)
19756c04344SDavid Nugent 		i++;		/* only use 'secure' data */
19856c04344SDavid Nugent 	}
19956c04344SDavid Nugent 	if (_secure_path(_PATH_LOGIN_CONF, 0, 0) != -1)
20068bbf3adSDavid Nugent 	    login_dbarray[i++] = _PATH_LOGIN_CONF;
20168bbf3adSDavid Nugent 	login_dbarray[i] = NULL;
20268bbf3adSDavid Nugent 
20356c04344SDavid Nugent 	memset(lc, 0, sizeof(login_cap_t));
20468bbf3adSDavid Nugent 	lc->lc_cap = lc->lc_class = lc->lc_style = NULL;
20568bbf3adSDavid Nugent 
20656c04344SDavid Nugent 	if (name == NULL || *name == '\0')
20756c04344SDavid Nugent 	    name = LOGIN_DEFCLASS;
20868bbf3adSDavid Nugent 
20956c04344SDavid Nugent 	switch (cgetent(&lc->lc_cap, login_dbarray, (char*)name)) {
21056c04344SDavid Nugent 	case -1:		/* Failed, entry does not exist */
21156c04344SDavid Nugent 	    if (strcmp(name, LOGIN_MECLASS) == 0)
21256c04344SDavid Nugent 		break;	/* Don't retry default on 'me' */
21356c04344SDavid Nugent 	    if (i == 0)
21456c04344SDavid Nugent 	        r = -1;
21556c04344SDavid Nugent 	    else if ((r = open(login_dbarray[0], O_RDONLY)) >= 0)
21656c04344SDavid Nugent 	        close(r);
21756c04344SDavid Nugent 	    /*
21856c04344SDavid Nugent 	     * If there's at least one login class database,
21956c04344SDavid Nugent 	     * and we aren't searching for a default class
22056c04344SDavid Nugent 	     * then complain about a non-existent class.
22156c04344SDavid Nugent 	     */
22256c04344SDavid Nugent 	    if (r >= 0 || strcmp(name, LOGIN_DEFCLASS) != 0)
22356c04344SDavid Nugent 		syslog(LOG_ERR, "login_getclass: unknown class '%s'", name);
22456c04344SDavid Nugent 	    /* fall-back to default class */
22556c04344SDavid Nugent 	    name = LOGIN_DEFCLASS;
22656c04344SDavid Nugent 	    msg = "%s: no default/fallback class '%s'";
22756c04344SDavid Nugent 	    if (cgetent(&lc->lc_cap, login_dbarray, (char*)name) != 0 && r >= 0)
22856c04344SDavid Nugent 		break;
22956c04344SDavid Nugent 	    /* Fallthru - just return system defaults */
23056c04344SDavid Nugent 	case 0:		/* success! */
23156c04344SDavid Nugent 	    if ((lc->lc_class = strdup(name)) != NULL) {
23256c04344SDavid Nugent 		++lc_object_count;
23368bbf3adSDavid Nugent 		return lc;
23468bbf3adSDavid Nugent 	    }
23556c04344SDavid Nugent 	    msg = "%s: strdup: %m";
23656c04344SDavid Nugent 	    break;
23756c04344SDavid Nugent 	case -2:
23856c04344SDavid Nugent 	    msg = "%s: retrieving class information: %m";
23956c04344SDavid Nugent 	    break;
24056c04344SDavid Nugent 	case -3:
24156c04344SDavid Nugent 	    msg = "%s: 'tc=' reference loop '%s'";
24256c04344SDavid Nugent 	    break;
24356c04344SDavid Nugent 	case 1:
24456c04344SDavid Nugent 	    msg = "couldn't resolve 'tc=' reference in '%s'";
24556c04344SDavid Nugent 	    break;
24656c04344SDavid Nugent 	default:
24756c04344SDavid Nugent 	    msg = "%s: unexpected cgetent() error '%s': %m";
24856c04344SDavid Nugent 	    break;
24956c04344SDavid Nugent 	}
25056c04344SDavid Nugent 	if (msg != NULL)
25156c04344SDavid Nugent 	    syslog(LOG_ERR, msg, "login_getclass", name);
25256c04344SDavid Nugent 	free(lc);
25356c04344SDavid Nugent     }
25468bbf3adSDavid Nugent 
25556c04344SDavid Nugent     return NULL;
25656c04344SDavid Nugent }
25756c04344SDavid Nugent 
25856c04344SDavid Nugent 
25956c04344SDavid Nugent 
26056c04344SDavid Nugent /*
26156c04344SDavid Nugent  * login_getclass()
26256c04344SDavid Nugent  * Get the login class for the system (only) login class database.
26356c04344SDavid Nugent  * Return a filled-out login_cap_t structure, including
26456c04344SDavid Nugent  * class name, and the capability record buffer.
26556c04344SDavid Nugent  */
26656c04344SDavid Nugent 
26756c04344SDavid Nugent login_cap_t *
26856c04344SDavid Nugent login_getclass(const char *cls)
26956c04344SDavid Nugent {
27056c04344SDavid Nugent     return login_getclassbyname(cls, NULL);
27156c04344SDavid Nugent }
27268bbf3adSDavid Nugent 
27368bbf3adSDavid Nugent 
27468bbf3adSDavid Nugent /*
27568bbf3adSDavid Nugent  * login_getclass()
27668bbf3adSDavid Nugent  * Get the login class for a given password entry from
27768bbf3adSDavid Nugent  * the system (only) login class database.
27868bbf3adSDavid Nugent  * If the password entry's class field is not set, or
27968bbf3adSDavid Nugent  * the class specified does not exist, then use the
28068bbf3adSDavid Nugent  * default of LOGIN_DEFCLASS (ie. "default").
28168bbf3adSDavid Nugent  * Return a filled-out login_cap_t structure, including
28268bbf3adSDavid Nugent  * class name, and the capability record buffer.
28368bbf3adSDavid Nugent  */
28468bbf3adSDavid Nugent 
28568bbf3adSDavid Nugent login_cap_t *
28656c04344SDavid Nugent login_getpwclass(const struct passwd *pwd)
28768bbf3adSDavid Nugent {
28856c04344SDavid Nugent     const char	*cls = NULL;
28956c04344SDavid Nugent 
2901c594de5SDavid Nugent     if (pwd != NULL) {
29156c04344SDavid Nugent 	cls = pwd->pw_class;
29256c04344SDavid Nugent 	if (cls == NULL || *cls == '\0')
29356c04344SDavid Nugent 	    cls = (pwd->pw_uid == 0) ? LOGIN_DEFROOTCLASS : LOGIN_DEFCLASS;
2942dc7d862SDavid Nugent     }
29556c04344SDavid Nugent     return login_getclassbyname(cls, pwd);
29668bbf3adSDavid Nugent }
29768bbf3adSDavid Nugent 
29868bbf3adSDavid Nugent 
29968bbf3adSDavid Nugent /*
30068bbf3adSDavid Nugent  * login_getuserclass()
30168bbf3adSDavid Nugent  * Get the login class for a given password entry, allowing user
30268bbf3adSDavid Nugent  * overrides via ~/.login_conf.
30368bbf3adSDavid Nugent  */
30468bbf3adSDavid Nugent 
30568bbf3adSDavid Nugent login_cap_t *
30668bbf3adSDavid Nugent login_getuserclass(const struct passwd *pwd)
30768bbf3adSDavid Nugent {
30856c04344SDavid Nugent     return login_getclassbyname(LOGIN_MECLASS, pwd);
30968bbf3adSDavid Nugent }
31068bbf3adSDavid Nugent 
31168bbf3adSDavid Nugent 
31268bbf3adSDavid Nugent 
31368bbf3adSDavid Nugent /*
31468bbf3adSDavid Nugent  * login_getcapstr()
31568bbf3adSDavid Nugent  * Given a login_cap entry, and a capability name, return the
31668bbf3adSDavid Nugent  * value defined for that capability, a defualt if not found, or
31768bbf3adSDavid Nugent  * an error string on error.
31868bbf3adSDavid Nugent  */
31968bbf3adSDavid Nugent 
32068bbf3adSDavid Nugent char *
32168bbf3adSDavid Nugent login_getcapstr(login_cap_t *lc, const char *cap, char *def, char *error)
32268bbf3adSDavid Nugent {
32368bbf3adSDavid Nugent     char    *res;
32468bbf3adSDavid Nugent     int	    ret;
32568bbf3adSDavid Nugent 
32668bbf3adSDavid Nugent     if (lc == NULL || cap == NULL || lc->lc_cap == NULL || *cap == '\0')
32768bbf3adSDavid Nugent 	return def;
32868bbf3adSDavid Nugent 
32956c04344SDavid Nugent     if ((ret = cgetstr(lc->lc_cap, (char *)cap, &res)) == -1)
33068bbf3adSDavid Nugent 	return def;
33156c04344SDavid Nugent     return (ret >= 0) ? res : error;
33268bbf3adSDavid Nugent }
33368bbf3adSDavid Nugent 
33468bbf3adSDavid Nugent 
33568bbf3adSDavid Nugent /*
33668bbf3adSDavid Nugent  * login_getcaplist()
33768bbf3adSDavid Nugent  * Given a login_cap entry, and a capability name, return the
33868bbf3adSDavid Nugent  * value defined for that capability split into an array of
33968bbf3adSDavid Nugent  * strings.
34068bbf3adSDavid Nugent  */
34168bbf3adSDavid Nugent 
34268bbf3adSDavid Nugent char **
34368bbf3adSDavid Nugent login_getcaplist(login_cap_t *lc, const char *cap, const char *chars)
34468bbf3adSDavid Nugent {
34568bbf3adSDavid Nugent     char    *lstring;
34668bbf3adSDavid Nugent 
34768bbf3adSDavid Nugent     if (chars == NULL)
348f01e3989SDavid Nugent 	chars = ", \t";
34968bbf3adSDavid Nugent     if ((lstring = login_getcapstr(lc, (char*)cap, NULL, NULL)) != NULL)
35068bbf3adSDavid Nugent 	return arrayize(lstring, chars, NULL);
35168bbf3adSDavid Nugent     return NULL;
35268bbf3adSDavid Nugent }
35368bbf3adSDavid Nugent 
35468bbf3adSDavid Nugent 
35568bbf3adSDavid Nugent /*
35668bbf3adSDavid Nugent  * login_getpath()
35768bbf3adSDavid Nugent  * From the login_cap_t <lc>, get the capability <cap> which is
35868bbf3adSDavid Nugent  * formatted as either a space or comma delimited list of paths
35968bbf3adSDavid Nugent  * and append them all into a string and separate by semicolons.
36068bbf3adSDavid Nugent  * If there is an error of any kind, return <error>.
36168bbf3adSDavid Nugent  */
36268bbf3adSDavid Nugent 
36368bbf3adSDavid Nugent char *
36468bbf3adSDavid Nugent login_getpath(login_cap_t *lc, const char *cap, char * error)
36568bbf3adSDavid Nugent {
36656c04344SDavid Nugent     char    *str;
36768bbf3adSDavid Nugent 
36856c04344SDavid Nugent     if ((str = login_getcapstr(lc, (char*)cap, NULL, NULL)) == NULL)
36968bbf3adSDavid Nugent 	str = error;
37068bbf3adSDavid Nugent     else {
3711c594de5SDavid Nugent 	char *ptr = str;
3721c594de5SDavid Nugent 
37368bbf3adSDavid Nugent 	while (*ptr) {
37468bbf3adSDavid Nugent 	    int count = strcspn(ptr, ", \t");
37568bbf3adSDavid Nugent 	    ptr += count;
37668bbf3adSDavid Nugent 	    if (*ptr)
37768bbf3adSDavid Nugent 		*ptr++ = ':';
37868bbf3adSDavid Nugent 	}
37968bbf3adSDavid Nugent     }
38068bbf3adSDavid Nugent     return str;
38168bbf3adSDavid Nugent }
38268bbf3adSDavid Nugent 
38368bbf3adSDavid Nugent 
38456c04344SDavid Nugent static int
38556c04344SDavid Nugent isinfinite(const char *s)
38656c04344SDavid Nugent {
38756c04344SDavid Nugent     static const char *infs[] = {
38856c04344SDavid Nugent 	"infinity",
38956c04344SDavid Nugent 	"inf",
39056c04344SDavid Nugent 	"unlimited",
39156c04344SDavid Nugent 	"unlimit",
39256c04344SDavid Nugent 	"-1",
39356c04344SDavid Nugent 	NULL
39456c04344SDavid Nugent     };
39556c04344SDavid Nugent     const char **i = &infs[0];
39656c04344SDavid Nugent 
39756c04344SDavid Nugent     while (*i != NULL) {
39856c04344SDavid Nugent 	if (strcasecmp(s, *i) == 0)
39956c04344SDavid Nugent 	    return 1;
40056c04344SDavid Nugent 	++i;
40156c04344SDavid Nugent     }
40256c04344SDavid Nugent     return 0;
40356c04344SDavid Nugent }
40456c04344SDavid Nugent 
40556c04344SDavid Nugent 
40656c04344SDavid Nugent static u_quad_t
40756c04344SDavid Nugent rmultiply(u_quad_t n1, u_quad_t n2)
40856c04344SDavid Nugent {
40956c04344SDavid Nugent     u_quad_t	m, r;
41056c04344SDavid Nugent     int		b1, b2;
41156c04344SDavid Nugent 
41256c04344SDavid Nugent     static int bpw = 0;
41356c04344SDavid Nugent 
41456c04344SDavid Nugent     /* Handle simple cases */
41556c04344SDavid Nugent     if (n1 == 0 || n2 == 0)
41656c04344SDavid Nugent 	return 0;
41756c04344SDavid Nugent     if (n1 == 1)
41856c04344SDavid Nugent 	return n2;
41956c04344SDavid Nugent     if (n2 == 1)
42056c04344SDavid Nugent 	return n1;
42156c04344SDavid Nugent 
42256c04344SDavid Nugent     /*
42356c04344SDavid Nugent      * sizeof() returns number of bytes needed for storage.
42456c04344SDavid Nugent      * This may be different from the actual number of useful bits.
42556c04344SDavid Nugent      */
42656c04344SDavid Nugent     if (!bpw) {
42756c04344SDavid Nugent 	bpw = sizeof(u_quad_t) * 8;
42856c04344SDavid Nugent 	while (((u_quad_t)1 << (bpw-1)) == 0)
42956c04344SDavid Nugent 	    --bpw;
43056c04344SDavid Nugent     }
43156c04344SDavid Nugent 
43256c04344SDavid Nugent     /*
43356c04344SDavid Nugent      * First check the magnitude of each number. If the sum of the
43456c04344SDavid Nugent      * magnatude is way to high, reject the number. (If this test
43556c04344SDavid Nugent      * is not done then the first multiply below may overflow.)
43656c04344SDavid Nugent      */
43756c04344SDavid Nugent     for (b1 = bpw; (((u_quad_t)1 << (b1-1)) & n1) == 0; --b1)
43856c04344SDavid Nugent 	;
43956c04344SDavid Nugent     for (b2 = bpw; (((u_quad_t)1 << (b2-1)) & n2) == 0; --b2)
44056c04344SDavid Nugent 	;
44156c04344SDavid Nugent     if (b1 + b2 - 2 > bpw) {
44256c04344SDavid Nugent 	errno = ERANGE;
44356c04344SDavid Nugent 	return (UQUAD_MAX);
44456c04344SDavid Nugent     }
44556c04344SDavid Nugent 
44656c04344SDavid Nugent     /*
44756c04344SDavid Nugent      * Decompose the multiplication to be:
44856c04344SDavid Nugent      * h1 = n1 & ~1
44956c04344SDavid Nugent      * h2 = n2 & ~1
45056c04344SDavid Nugent      * l1 = n1 & 1
45156c04344SDavid Nugent      * l2 = n2 & 1
45256c04344SDavid Nugent      * (h1 + l1) * (h2 + l2)
45356c04344SDavid Nugent      * (h1 * h2) + (h1 * l2) + (l1 * h2) + (l1 * l2)
45456c04344SDavid Nugent      *
45556c04344SDavid Nugent      * Since h1 && h2 do not have the low bit set, we can then say:
45656c04344SDavid Nugent      *
45756c04344SDavid Nugent      * (h1>>1 * h2>>1 * 4) + ...
45856c04344SDavid Nugent      *
45956c04344SDavid Nugent      * So if (h1>>1 * h2>>1) > (1<<(bpw - 2)) then the result will
46056c04344SDavid Nugent      * overflow.
46156c04344SDavid Nugent      *
46256c04344SDavid Nugent      * Finally, if MAX - ((h1 * l2) + (l1 * h2) + (l1 * l2)) < (h1*h2)
46356c04344SDavid Nugent      * then adding in residual amout will cause an overflow.
46456c04344SDavid Nugent      */
46556c04344SDavid Nugent 
46656c04344SDavid Nugent     m = (n1 >> 1) * (n2 >> 1);
46756c04344SDavid Nugent     if (m >= ((u_quad_t)1 << (bpw-2))) {
46856c04344SDavid Nugent 	errno = ERANGE;
46956c04344SDavid Nugent 	return (UQUAD_MAX);
47056c04344SDavid Nugent     }
47156c04344SDavid Nugent     m *= 4;
47256c04344SDavid Nugent 
47356c04344SDavid Nugent     r = (n1 & n2 & 1)
47456c04344SDavid Nugent 	+ (n2 & 1) * (n1 & ~(u_quad_t)1)
47556c04344SDavid Nugent 	+ (n1 & 1) * (n2 & ~(u_quad_t)1);
47656c04344SDavid Nugent 
47756c04344SDavid Nugent     if ((u_quad_t)(m + r) < m) {
47856c04344SDavid Nugent 	errno = ERANGE;
47956c04344SDavid Nugent 	return (UQUAD_MAX);
48056c04344SDavid Nugent     }
48156c04344SDavid Nugent     m += r;
48256c04344SDavid Nugent 
48356c04344SDavid Nugent     return (m);
48456c04344SDavid Nugent }
48556c04344SDavid Nugent 
48656c04344SDavid Nugent 
48768bbf3adSDavid Nugent /*
48868bbf3adSDavid Nugent  * login_getcaptime()
48968bbf3adSDavid Nugent  * From the login_cap_t <lc>, get the capability <cap>, which is
49068bbf3adSDavid Nugent  * formatted as a time (e.g., "<cap>=10h3m2s").  If <cap> is not
49168bbf3adSDavid Nugent  * present in <lc>, return <def>; if there is an error of some kind,
49268bbf3adSDavid Nugent  * return <error>.
49368bbf3adSDavid Nugent  */
49468bbf3adSDavid Nugent 
49568bbf3adSDavid Nugent rlim_t
49668bbf3adSDavid Nugent login_getcaptime(login_cap_t *lc, const char *cap, rlim_t def, rlim_t error)
49768bbf3adSDavid Nugent {
49856c04344SDavid Nugent     char    *res, *ep, *oval;
49956c04344SDavid Nugent     int	    r;
50051706563SDavid Nugent     rlim_t  tot;
50168bbf3adSDavid Nugent 
50268bbf3adSDavid Nugent     errno = 0;
50368bbf3adSDavid Nugent     if (lc == NULL || lc->lc_cap == NULL)
50468bbf3adSDavid Nugent 	return def;
50568bbf3adSDavid Nugent 
50668bbf3adSDavid Nugent     /*
50768bbf3adSDavid Nugent      * Look for <cap> in lc_cap.
50868bbf3adSDavid Nugent      * If it's not there (-1), return <def>.
50968bbf3adSDavid Nugent      * If there's an error, return <error>.
51068bbf3adSDavid Nugent      */
51168bbf3adSDavid Nugent 
51256c04344SDavid Nugent     if ((r = cgetstr(lc->lc_cap, (char *)cap, &res)) == -1)
51368bbf3adSDavid Nugent 	return def;
51456c04344SDavid Nugent     else if (r < 0) {
51556c04344SDavid Nugent 	errno = ERANGE;
51668bbf3adSDavid Nugent 	return error;
51756c04344SDavid Nugent     }
51868bbf3adSDavid Nugent 
51956c04344SDavid Nugent     /* "inf" and "infinity" are special cases */
52056c04344SDavid Nugent     if (isinfinite(res))
52168bbf3adSDavid Nugent 	return RLIM_INFINITY;
52268bbf3adSDavid Nugent 
52368bbf3adSDavid Nugent     /*
52468bbf3adSDavid Nugent      * Now go through the string, turning something like 1h2m3s into
52568bbf3adSDavid Nugent      * an integral value.  Whee.
52668bbf3adSDavid Nugent      */
52768bbf3adSDavid Nugent 
52868bbf3adSDavid Nugent     errno = 0;
52951706563SDavid Nugent     tot = 0;
53056c04344SDavid Nugent     oval = res;
53168bbf3adSDavid Nugent     while (*res) {
53256c04344SDavid Nugent 	rlim_t tim = strtoq(res, &ep, 0);
53356c04344SDavid Nugent 	rlim_t mult = 1;
53456c04344SDavid Nugent 
53556c04344SDavid Nugent 	if (ep == NULL || ep == res || errno != 0) {
53656c04344SDavid Nugent 	invalid:
53756c04344SDavid Nugent 	    syslog(LOG_WARNING, "login_getcaptime: class '%s' bad value %s=%s",
53856c04344SDavid Nugent 		   lc->lc_class, cap, oval);
53956c04344SDavid Nugent 	    errno = ERANGE;
54068bbf3adSDavid Nugent 	    return error;
54168bbf3adSDavid Nugent 	}
54268bbf3adSDavid Nugent 	/* Look for suffixes */
54368bbf3adSDavid Nugent 	switch (*ep++) {
54468bbf3adSDavid Nugent 	case 0:
54556c04344SDavid Nugent 	    ep--;
54656c04344SDavid Nugent 	    break;	/* end of string */
54768bbf3adSDavid Nugent 	case 's': case 'S':	/* seconds */
54868bbf3adSDavid Nugent 	    break;
54968bbf3adSDavid Nugent 	case 'm': case 'M':	/* minutes */
55056c04344SDavid Nugent 	    mult = 60;
55168bbf3adSDavid Nugent 	    break;
55268bbf3adSDavid Nugent 	case 'h': case 'H':	/* hours */
55356c04344SDavid Nugent 	    mult = 60L * 60L;
55468bbf3adSDavid Nugent 	    break;
55568bbf3adSDavid Nugent 	case 'd': case 'D':	/* days */
55656c04344SDavid Nugent 	    mult = 60L * 60L * 24L;
55768bbf3adSDavid Nugent 	    break;
55868bbf3adSDavid Nugent 	case 'w': case 'W':	/* weeks */
55956c04344SDavid Nugent 	    mult = 60L * 60L * 24L * 7L;
56056c04344SDavid Nugent 	case 'y': case 'Y':	/* 365-day years */
56156c04344SDavid Nugent 	    mult = 60L * 60L * 24L * 365L;
56268bbf3adSDavid Nugent 	default:
56356c04344SDavid Nugent 	    goto invalid;
56468bbf3adSDavid Nugent 	}
56568bbf3adSDavid Nugent 	res = ep;
56656c04344SDavid Nugent 	tot += rmultiply(tim, mult);
56756c04344SDavid Nugent 	if (errno)
56856c04344SDavid Nugent 	    goto invalid;
56968bbf3adSDavid Nugent     }
57056c04344SDavid Nugent 
57168bbf3adSDavid Nugent     return tot;
57268bbf3adSDavid Nugent }
57368bbf3adSDavid Nugent 
57468bbf3adSDavid Nugent 
57568bbf3adSDavid Nugent /*
57668bbf3adSDavid Nugent  * login_getcapnum()
57768bbf3adSDavid Nugent  * From the login_cap_t <lc>, extract the numerical value <cap>.
57868bbf3adSDavid Nugent  * If it is not present, return <def> for a default, and return
57968bbf3adSDavid Nugent  * <error> if there is an error.
58068bbf3adSDavid Nugent  * Like login_getcaptime(), only it only converts to a number, not
58168bbf3adSDavid Nugent  * to a time; "infinity" and "inf" are 'special.'
58268bbf3adSDavid Nugent  */
58368bbf3adSDavid Nugent 
58468bbf3adSDavid Nugent rlim_t
58568bbf3adSDavid Nugent login_getcapnum(login_cap_t *lc, const char *cap, rlim_t def, rlim_t error)
58668bbf3adSDavid Nugent {
58768bbf3adSDavid Nugent     char    *ep, *res;
58856c04344SDavid Nugent     int	    r;
58968bbf3adSDavid Nugent     rlim_t  val;
59068bbf3adSDavid Nugent 
59168bbf3adSDavid Nugent     if (lc == NULL || lc->lc_cap == NULL)
59268bbf3adSDavid Nugent 	return def;
59368bbf3adSDavid Nugent 
59468bbf3adSDavid Nugent     /*
59568bbf3adSDavid Nugent      * For BSDI compatibility, try for the tag=<val> first
59668bbf3adSDavid Nugent      */
59756c04344SDavid Nugent     if ((r = cgetstr(lc->lc_cap, (char *)cap, &res)) == -1) {
59868bbf3adSDavid Nugent 	long	lval;
59956c04344SDavid Nugent 	/* string capability not present, so try for tag#<val> as numeric */
60056c04344SDavid Nugent 	if ((r = cgetnum(lc->lc_cap, (char *)cap, &lval)) == -1)
60168bbf3adSDavid Nugent 	    return def; /* Not there, so return default */
60256c04344SDavid Nugent 	else if (r >= 0)
60368bbf3adSDavid Nugent 	    return (rlim_t)lval;
60468bbf3adSDavid Nugent     }
60568bbf3adSDavid Nugent 
60656c04344SDavid Nugent     if (r < 0) {
60756c04344SDavid Nugent 	errno = ERANGE;
60856c04344SDavid Nugent 	return error;
60956c04344SDavid Nugent     }
61056c04344SDavid Nugent 
61156c04344SDavid Nugent     if (isinfinite(res))
61268bbf3adSDavid Nugent 	return RLIM_INFINITY;
61368bbf3adSDavid Nugent 
61468bbf3adSDavid Nugent     errno = 0;
61556c04344SDavid Nugent     val = strtoq(res, &ep, 0);
61656c04344SDavid Nugent     if (ep == NULL || ep == res || errno != 0) {
61756c04344SDavid Nugent 	syslog(LOG_WARNING, "login_getcapnum: class '%s' bad value %s=%s",
61856c04344SDavid Nugent 	       lc->lc_class, cap, res);
61956c04344SDavid Nugent 	errno = ERANGE;
62068bbf3adSDavid Nugent 	return error;
62156c04344SDavid Nugent     }
62256c04344SDavid Nugent 
62368bbf3adSDavid Nugent     return val;
62468bbf3adSDavid Nugent }
62568bbf3adSDavid Nugent 
62668bbf3adSDavid Nugent 
62756c04344SDavid Nugent 
62868bbf3adSDavid Nugent /*
62968bbf3adSDavid Nugent  * login_getcapsize()
63068bbf3adSDavid Nugent  * From the login_cap_t <lc>, extract the capability <cap>, which is
63168bbf3adSDavid Nugent  * formatted as a size (e.g., "<cap>=10M"); it can also be "infinity".
63268bbf3adSDavid Nugent  * If not present, return <def>, or <error> if there is an error of
63368bbf3adSDavid Nugent  * some sort.
63468bbf3adSDavid Nugent  */
63568bbf3adSDavid Nugent 
63668bbf3adSDavid Nugent rlim_t
63756c04344SDavid Nugent login_getcapsize(login_cap_t *lc, const char *cap, rlim_t def, rlim_t error)
63856c04344SDavid Nugent {
63956c04344SDavid Nugent     char    *ep, *res, *oval;
64056c04344SDavid Nugent     int	    r;
64156c04344SDavid Nugent     rlim_t  tot;
64268bbf3adSDavid Nugent 
64368bbf3adSDavid Nugent     if (lc == NULL || lc->lc_cap == NULL)
64468bbf3adSDavid Nugent 	return def;
64568bbf3adSDavid Nugent 
64656c04344SDavid Nugent     if ((r = cgetstr(lc->lc_cap, (char *)cap, &res)) == -1)
64768bbf3adSDavid Nugent 	return def;
64856c04344SDavid Nugent     else if (r < 0) {
64956c04344SDavid Nugent 	errno = ERANGE;
65068bbf3adSDavid Nugent 	return error;
65156c04344SDavid Nugent     }
65268bbf3adSDavid Nugent 
65356c04344SDavid Nugent     if (isinfinite(res))
65465f50b7fSAndrey A. Chernov 	return RLIM_INFINITY;
65565f50b7fSAndrey A. Chernov 
65668bbf3adSDavid Nugent     errno = 0;
65751706563SDavid Nugent     tot = 0;
65856c04344SDavid Nugent     oval = res;
65951706563SDavid Nugent     while (*res) {
66056c04344SDavid Nugent 	rlim_t siz = strtoq(res, &ep, 0);
66156c04344SDavid Nugent 	rlim_t mult = 1;
66256c04344SDavid Nugent 
66356c04344SDavid Nugent 	if (ep == NULL || ep == res || errno != 0) {
66456c04344SDavid Nugent 	invalid:
66556c04344SDavid Nugent 	    syslog(LOG_WARNING, "login_getcapsize: class '%s' bad value %s=%s",
66656c04344SDavid Nugent 		   lc->lc_class, cap, oval);
66756c04344SDavid Nugent 	    errno = ERANGE;
66868bbf3adSDavid Nugent 	    return error;
66956c04344SDavid Nugent 	}
670f9074e29SDavid Nugent 	switch (*ep++) {
67168bbf3adSDavid Nugent 	case 0:	/* end of string */
67251706563SDavid Nugent 	    ep--;
67351706563SDavid Nugent 	    break;
67468bbf3adSDavid Nugent 	case 'b': case 'B':	/* 512-byte blocks */
67556c04344SDavid Nugent 	    mult = 512;
67656c04344SDavid Nugent 	    break;
67768bbf3adSDavid Nugent 	case 'k': case 'K':	/* 1024-byte Kilobytes */
67856c04344SDavid Nugent 	    mult = 1024;
67956c04344SDavid Nugent 	    break;
68068bbf3adSDavid Nugent 	case 'm': case 'M':	/* 1024-k kbytes */
68156c04344SDavid Nugent 	    mult = 1024 * 1024;
68256c04344SDavid Nugent 	    break;
68368bbf3adSDavid Nugent 	case 'g': case 'G':	/* 1Gbyte */
68456c04344SDavid Nugent 	    mult = 1024 * 1024 * 1024;
68556c04344SDavid Nugent 	    break;
68668bbf3adSDavid Nugent 	case 't': case 'T':	/* 1TBte */
68756c04344SDavid Nugent 	    mult = 1024LL * 1024LL * 1024LL * 1024LL;
68856c04344SDavid Nugent 	    break;
68968bbf3adSDavid Nugent 	default:
69056c04344SDavid Nugent 	    goto invalid;
69168bbf3adSDavid Nugent 	}
692f9074e29SDavid Nugent 	res = ep;
69356c04344SDavid Nugent 	tot += rmultiply(siz, mult);
69456c04344SDavid Nugent 	if (errno)
69556c04344SDavid Nugent 	    goto invalid;
69651706563SDavid Nugent     }
69756c04344SDavid Nugent 
69851706563SDavid Nugent     return tot;
69968bbf3adSDavid Nugent }
70068bbf3adSDavid Nugent 
70168bbf3adSDavid Nugent 
70268bbf3adSDavid Nugent /*
70368bbf3adSDavid Nugent  * login_getcapbool()
70468bbf3adSDavid Nugent  * From the login_cap_t <lc>, check for the existance of the capability
70568bbf3adSDavid Nugent  * of <cap>.  Return <def> if <lc>->lc_cap is NULL, otherwise return
70668bbf3adSDavid Nugent  * the whether or not <cap> exists there.
70768bbf3adSDavid Nugent  */
70868bbf3adSDavid Nugent 
70968bbf3adSDavid Nugent int
71068bbf3adSDavid Nugent login_getcapbool(login_cap_t *lc, const char *cap, int def)
71168bbf3adSDavid Nugent {
71268bbf3adSDavid Nugent     if (lc == NULL || lc->lc_cap == NULL)
71368bbf3adSDavid Nugent 	return def;
71468bbf3adSDavid Nugent     return (cgetcap(lc->lc_cap, (char *)cap, ':') != NULL);
71568bbf3adSDavid Nugent }
71668bbf3adSDavid Nugent 
71768bbf3adSDavid Nugent 
71868bbf3adSDavid Nugent /*
71968bbf3adSDavid Nugent  * login_getstyle()
72068bbf3adSDavid Nugent  * Given a login_cap entry <lc>, and optionally a type of auth <auth>,
72168bbf3adSDavid Nugent  * and optionally a style <style>, find the style that best suits these
72268bbf3adSDavid Nugent  * rules:
72368bbf3adSDavid Nugent  *	1.  If <auth> is non-null, look for an "auth-<auth>=" string
72468bbf3adSDavid Nugent  *	in the capability; if not present, default to "auth=".
72568bbf3adSDavid Nugent  *	2.  If there is no auth list found from (1), default to
72668bbf3adSDavid Nugent  *	"passwd" as an authorization list.
72768bbf3adSDavid Nugent  *	3.  If <style> is non-null, look for <style> in the list of
72868bbf3adSDavid Nugent  *	authorization methods found from (2); if <style> is NULL, default
72968bbf3adSDavid Nugent  *	to LOGIN_DEFSTYLE ("passwd").
73068bbf3adSDavid Nugent  *	4.  If the chosen style is found in the chosen list of authorization
73168bbf3adSDavid Nugent  *	methods, return that; otherwise, return NULL.
73268bbf3adSDavid Nugent  * E.g.:
73368bbf3adSDavid Nugent  *     login_getstyle(lc, NULL, "ftp");
73468bbf3adSDavid Nugent  *     login_getstyle(lc, "login", NULL);
73568bbf3adSDavid Nugent  *     login_getstyle(lc, "skey", "network");
73668bbf3adSDavid Nugent  */
73768bbf3adSDavid Nugent 
73868bbf3adSDavid Nugent char *
73968bbf3adSDavid Nugent login_getstyle(login_cap_t *lc, char *style, const char *auth)
74068bbf3adSDavid Nugent {
74168bbf3adSDavid Nugent     int	    i;
74268bbf3adSDavid Nugent     char    **authtypes = NULL;
74368bbf3adSDavid Nugent     char    *auths= NULL;
74468bbf3adSDavid Nugent     char    realauth[64];
74568bbf3adSDavid Nugent 
74668bbf3adSDavid Nugent     static char *defauthtypes[] = { LOGIN_DEFSTYLE, NULL };
74768bbf3adSDavid Nugent 
74856c04344SDavid Nugent     if (auth != NULL && *auth != '\0') {
74956c04344SDavid Nugent 	if (snprintf(realauth, sizeof realauth, "auth-%s", auth) < sizeof realauth)
75068bbf3adSDavid Nugent 	    authtypes = login_getcaplist(lc, realauth, NULL);
75156c04344SDavid Nugent     }
75268bbf3adSDavid Nugent 
75368bbf3adSDavid Nugent     if (authtypes == NULL)
75468bbf3adSDavid Nugent 	authtypes = login_getcaplist(lc, "auth", NULL);
75568bbf3adSDavid Nugent 
75668bbf3adSDavid Nugent     if (authtypes == NULL)
75768bbf3adSDavid Nugent 	authtypes = defauthtypes;
75868bbf3adSDavid Nugent 
75968bbf3adSDavid Nugent     /*
76068bbf3adSDavid Nugent      * We have at least one authtype now; auths is a comma-seperated
76168bbf3adSDavid Nugent      * (or space-separated) list of authentication types.  We have to
76268bbf3adSDavid Nugent      * convert from this to an array of char*'s; authtypes then gets this.
76368bbf3adSDavid Nugent      */
76468bbf3adSDavid Nugent     i = 0;
76568bbf3adSDavid Nugent     if (style != NULL && *style != '\0') {
76668bbf3adSDavid Nugent 	while (authtypes[i] != NULL && strcmp(style, authtypes[i]) != 0)
76768bbf3adSDavid Nugent 	    i++;
76868bbf3adSDavid Nugent     }
76956c04344SDavid Nugent 
77068bbf3adSDavid Nugent     lc->lc_style = NULL;
77168bbf3adSDavid Nugent     if (authtypes[i] != NULL && (auths = strdup(authtypes[i])) != NULL)
77268bbf3adSDavid Nugent 	lc->lc_style = auths;
77368bbf3adSDavid Nugent 
77456c04344SDavid Nugent     if (lc->lc_style != NULL)
77556c04344SDavid Nugent 	lc->lc_style = strdup(lc->lc_style);
77656c04344SDavid Nugent 
77768bbf3adSDavid Nugent     return lc->lc_style;
77868bbf3adSDavid Nugent }
779