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