[BACK]Return to login_cap.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libutil

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libutil/login_cap.c between version 1.5 and 1.5.4.1

version 1.5, 2000/02/10 20:52:54 version 1.5.4.1, 2000/10/18 03:44:59
Line 1 
Line 1 
 /* $NetBSD$ */  /*      $NetBSD$        */
   
 /*-  /*-
  * Copyright (c) 1995,1997 Berkeley Software Design, Inc. All rights reserved.   * Copyright (c) 1995,1997 Berkeley Software Design, Inc. All rights reserved.
Line 33 
Line 33 
  *   *
  *      BSDI login_cap.c,v 2.13 1998/02/07 03:17:05 prb Exp   *      BSDI login_cap.c,v 2.13 1998/02/07 03:17:05 prb Exp
  */   */
   
   #include <sys/cdefs.h>
   #if defined(LIBC_SCCS) && !defined(lint)
   __RCSID("$NetBSD$");
   #endif /* LIBC_SCCS and not lint */
   
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/stat.h>  #include <sys/stat.h>
Line 52 
Line 57 
 #include <string.h>  #include <string.h>
 #include <syslog.h>  #include <syslog.h>
 #include <unistd.h>  #include <unistd.h>
   #include <util.h>
   
   static void     setuserpath(login_cap_t *, char *);
 static  char *classfiles[] = { _PATH_LOGIN_CONF, 0 };  static u_quad_t multiply(u_quad_t, u_quad_t);
 static  void setuserpath __P((login_cap_t *, char *));  static u_quad_t strtolimit(char *, char **, int);
 static  u_quad_t multiply __P((u_quad_t, u_quad_t));  static u_quad_t strtosize(char *, char **, int);
 static  u_quad_t strtolimit __P((char *, char **, int));  static int      gsetrl(login_cap_t *, int, char *, int type);
 static  u_quad_t strtosize __P((char *, char **, int));  static int      setuserenv(login_cap_t *);
 static  int gsetrl __P((login_cap_t *, int, char *, int type));  static int      isinfinite(const char *);
 static  int setuserenv __P((login_cap_t *));  
 static  int isinfinite __P((const char *));  
   
 login_cap_t *  login_cap_t *
 login_getclass(class)  login_getclass(char *class)
         char *class;  
 {  {
           char *classfiles[2];
         login_cap_t *lc;          login_cap_t *lc;
         int res;          int res;
   
         for (res = 0; classfiles[res]; ++res)          if (secure_path(_PATH_LOGIN_CONF) == 0) {
                 if (secure_path(classfiles[res]) < 0)                  classfiles[0] = _PATH_LOGIN_CONF;
                         return (0);                  classfiles[1] = NULL;
           } else {
                   classfiles[0] = NULL;
           }
   
         if ((lc = malloc(sizeof(login_cap_t))) == NULL) {          if ((lc = malloc(sizeof(login_cap_t))) == NULL) {
                 syslog(LOG_ERR, "%s:%d malloc: %m", __FILE__, __LINE__);                  syslog(LOG_ERR, "%s:%d malloc: %m", __FILE__, __LINE__);
Line 91  login_getclass(class)
Line 98  login_getclass(class)
                 return (0);                  return (0);
         }          }
   
         if ((res = cgetent(&lc->lc_cap, classfiles, lc->lc_class)) != 0 ) {          /*
            * Not having a login.conf file is not an error condition.
            * The individual routines deal reasonably with missing
            * capabilities and use default values.
            */
           if (classfiles[0] == NULL)
                   return(lc);
   
           if ((res = cgetent(&lc->lc_cap, classfiles, lc->lc_class)) != 0) {
                 lc->lc_cap = 0;                  lc->lc_cap = 0;
                 switch (res) {                  switch (res) {
                 case 1:                  case 1:
Line 127  login_getclass(class)
Line 142  login_getclass(class)
 }  }
   
 login_cap_t *  login_cap_t *
 login_getpwclass(pwd)  login_getpwclass(const struct passwd *pwd)
         const struct passwd *pwd;  
 {  {
         return login_getclass(pwd ? pwd->pw_class : NULL);          return login_getclass(pwd ? pwd->pw_class : NULL);
 }  }
   
 char *  char *
 login_getcapstr(lc, cap, def, e)  login_getcapstr(login_cap_t *lc, char *cap, char *def, char *e)
         login_cap_t *lc;  
         char *cap;  
         char *def;  
         char *e;  
 {  {
         char *res;          char *res;
         int status;          int status;
Line 165  login_getcapstr(lc, cap, def, e)
Line 175  login_getcapstr(lc, cap, def, e)
 }  }
   
 quad_t  quad_t
 login_getcaptime(lc, cap, def, e)  login_getcaptime(login_cap_t *lc, char *cap, quad_t def, quad_t e)
         login_cap_t *lc;  
         char *cap;  
         quad_t def;  
         quad_t e;  
 {  {
         char *ep;          char *ep;
         char *res, *sres;          char *res, *sres;
Line 245  invalid:
Line 251  invalid:
 }  }
   
 quad_t  quad_t
 login_getcapnum(lc, cap, def, e)  login_getcapnum(login_cap_t *lc, char *cap, quad_t def, quad_t e)
         login_cap_t *lc;  
         char *cap;  
         quad_t def;  
         quad_t e;  
 {  {
         char *ep;          char *ep;
         char *res;          char *res;
Line 293  login_getcapnum(lc, cap, def, e)
Line 295  login_getcapnum(lc, cap, def, e)
 }  }
   
 quad_t  quad_t
 login_getcapsize(lc, cap, def, e)  login_getcapsize(login_cap_t *lc, char *cap, quad_t def, quad_t e)
         login_cap_t *lc;  
         char *cap;  
         quad_t def;  
         quad_t e;  
 {  {
         char *ep;          char *ep;
         char *res;          char *res;
Line 339  login_getcapsize(lc, cap, def, e)
Line 337  login_getcapsize(lc, cap, def, e)
 }  }
   
 int  int
 login_getcapbool(lc, cap, def)  login_getcapbool(login_cap_t *lc, char *cap, u_int def)
         login_cap_t *lc;  
         char *cap;  
         u_int def;  
 {  {
         if (!lc || !lc->lc_cap)          if (!lc || !lc->lc_cap)
                 return (def);                  return (def);
Line 351  login_getcapbool(lc, cap, def)
Line 346  login_getcapbool(lc, cap, def)
 }  }
   
 void  void
 login_close(lc)  login_close(login_cap_t *lc)
         login_cap_t *lc;  
 {  {
         if (lc) {          if (lc) {
                 if (lc->lc_class)                  if (lc->lc_class)
Line 365  login_close(lc)
Line 359  login_close(lc)
         }          }
 }  }
   
 #define CTIME   1  #define R_CTIME 1
 #define CSIZE   2  #define R_CSIZE 2
 #define CNUMB   3  #define R_CNUMB 3
   
 static struct {  static struct {
         int     what;          int     what;
         int     type;          int     type;
         char *  name;          char *  name;
 } r_list[] = {  } r_list[] = {
         { RLIMIT_CPU,           CTIME, "cputime", },          { RLIMIT_CPU,           R_CTIME, "cputime", },
         { RLIMIT_FSIZE,         CSIZE, "filesize", },          { RLIMIT_FSIZE,         R_CSIZE, "filesize", },
         { RLIMIT_DATA,          CSIZE, "datasize", },          { RLIMIT_DATA,          R_CSIZE, "datasize", },
         { RLIMIT_STACK,         CSIZE, "stacksize", },          { RLIMIT_STACK,         R_CSIZE, "stacksize", },
         { RLIMIT_RSS,           CSIZE, "memoryuse", },          { RLIMIT_RSS,           R_CSIZE, "memoryuse", },
         { RLIMIT_MEMLOCK,       CSIZE, "memorylocked", },          { RLIMIT_MEMLOCK,       R_CSIZE, "memorylocked", },
         { RLIMIT_NPROC,         CNUMB, "maxproc", },          { RLIMIT_NPROC,         R_CNUMB, "maxproc", },
         { RLIMIT_NOFILE,        CNUMB, "openfiles", },          { RLIMIT_NOFILE,        R_CNUMB, "openfiles", },
         { RLIMIT_CORE,          CSIZE, "coredumpsize", },          { RLIMIT_CORE,          R_CSIZE, "coredumpsize", },
         { -1, 0, 0 }          { -1, 0, 0 }
 };  };
   
 static int  static int
 gsetrl(lc, what, name, type)  gsetrl(login_cap_t *lc, int what, char *name, int type)
         login_cap_t *lc;  
         int what;  
         char *name;  
         int type;  
 {  {
         struct rlimit rl;          struct rlimit rl;
         struct rlimit r;          struct rlimit r;
Line 410  gsetrl(lc, what, name, type)
Line 400  gsetrl(lc, what, name, type)
 #define RMAX    r.rlim_max  #define RMAX    r.rlim_max
   
         switch (type) {          switch (type) {
         case CTIME:          case R_CTIME:
                 RCUR = login_getcaptime(lc, name, RCUR, RCUR);                  RCUR = login_getcaptime(lc, name, RCUR, RCUR);
                 RMAX = login_getcaptime(lc, name, RMAX, RMAX);                  RMAX = login_getcaptime(lc, name, RMAX, RMAX);
                 rl.rlim_cur = login_getcaptime(lc, name_cur, RCUR, RCUR);                  rl.rlim_cur = login_getcaptime(lc, name_cur, RCUR, RCUR);
                 rl.rlim_max = login_getcaptime(lc, name_max, RMAX, RMAX);                  rl.rlim_max = login_getcaptime(lc, name_max, RMAX, RMAX);
                 break;                  break;
         case CSIZE:          case R_CSIZE:
                 RCUR = login_getcapsize(lc, name, RCUR, RCUR);                  RCUR = login_getcapsize(lc, name, RCUR, RCUR);
                 RMAX = login_getcapsize(lc, name, RMAX, RMAX);                  RMAX = login_getcapsize(lc, name, RMAX, RMAX);
                 rl.rlim_cur = login_getcapsize(lc, name_cur, RCUR, RCUR);                  rl.rlim_cur = login_getcapsize(lc, name_cur, RCUR, RCUR);
                 rl.rlim_max = login_getcapsize(lc, name_max, RMAX, RMAX);                  rl.rlim_max = login_getcapsize(lc, name_max, RMAX, RMAX);
                 break;                  break;
         case CNUMB:          case R_CNUMB:
                 RCUR = login_getcapnum(lc, name, RCUR, RCUR);                  RCUR = login_getcapnum(lc, name, RCUR, RCUR);
                 RMAX = login_getcapnum(lc, name, RMAX, RMAX);                  RMAX = login_getcapnum(lc, name, RMAX, RMAX);
                 rl.rlim_cur = login_getcapnum(lc, name_cur, RCUR, RCUR);                  rl.rlim_cur = login_getcapnum(lc, name_cur, RCUR, RCUR);
Line 443  gsetrl(lc, what, name, type)
Line 433  gsetrl(lc, what, name, type)
 }  }
   
 static int  static int
 setuserenv(lc)  setuserenv(login_cap_t *lc)
         login_cap_t *lc;  
 {  {
         char *stop = ", \t";          char *stop = ", \t";
         int i, count;          int i, count;
Line 452  setuserenv(lc)
Line 441  setuserenv(lc)
         char **res;          char **res;
         char *str = login_getcapstr(lc, "setenv", NULL, NULL);          char *str = login_getcapstr(lc, "setenv", NULL, NULL);
   
         if(str == NULL || *str == '\0')          if (str == NULL || *str == '\0')
                 return 0;                  return 0;
   
         /* count the sub-strings */          /* count the sub-strings */
Line 460  setuserenv(lc)
Line 449  setuserenv(lc)
                 ptr += strcspn(ptr, stop);                  ptr += strcspn(ptr, stop);
                 if (*ptr)                  if (*ptr)
                         ptr++;                          ptr++;
                 }          }
   
         /* allocate ptr array and string */          /* allocate ptr array and string */
         count = i;          count = i;
         res = malloc( count * sizeof(char *) + strlen(str) + 1 );          res = malloc(count * sizeof(char *) + strlen(str) + 1);
   
         if(!res)          if (!res)
                 return -1;                  return -1;
   
         ptr = (char *)res + count * sizeof(char *);          ptr = (char *)res + count * sizeof(char *);
Line 478  setuserenv(lc)
Line 467  setuserenv(lc)
                 ptr += strcspn(ptr, stop);                  ptr += strcspn(ptr, stop);
                 if (*ptr)                  if (*ptr)
                         *ptr++ = '\0';                          *ptr++ = '\0';
                 }          }
   
         res[i] = NULL;          res[i] = NULL;
   
         for (i = 0; i < count && res[i]; i++) {          for (i = 0; i < count && res[i]; i++) {
                 if (*res[i] != '\0') {                  if (*res[i] != '\0') {
                         if ((ptr = strchr(res[i], '=')))                          if ((ptr = strchr(res[i], '=')) != NULL)
                                 *ptr++ = '\0';                                  *ptr++ = '\0';
                         else                          else
                                 ptr = "";                                  ptr = "";
Line 496  setuserenv(lc)
Line 485  setuserenv(lc)
         return 0;          return 0;
 }  }
   
   
 int  int
 setclasscontext(class, flags)  setclasscontext(char *class, u_int flags)
         char *class;  
         u_int flags;  
 {  {
         int ret;          int ret;
         login_cap_t *lc;          login_cap_t *lc;
Line 515  setclasscontext(class, flags)
Line 501  setclasscontext(class, flags)
 }  }
   
 int  int
 setusercontext(lc, pwd, uid, flags)  setusercontext(login_cap_t *lc, struct passwd *pwd, uid_t uid, u_int flags)
         login_cap_t *lc;  
         struct passwd *pwd;  
         uid_t uid;  
         u_int flags;  
 {  {
         login_cap_t *flc;          login_cap_t *flc;
         quad_t p;          quad_t p;
Line 597  setusercontext(lc, pwd, uid, flags)
Line 579  setusercontext(lc, pwd, uid, flags)
 }  }
   
 static void  static void
 setuserpath(lc, home)  setuserpath(login_cap_t *lc, char *home)
         login_cap_t *lc;  
         char *home;  
 {  {
         size_t hlen, plen;          size_t hlen, plen;
         int cnt = 0;          int cnt = 0;
Line 659  setuserpath(lc, home)
Line 639  setuserpath(lc, home)
  *         seperated by x (also * for backwards compatibility), specifying   *         seperated by x (also * for backwards compatibility), specifying
  *         the product of the indicated values.   *         the product of the indicated values.
  */   */
 static  static u_quad_t
 u_quad_t  strtosize(char *str, char **endptr, int radix)
 strtosize(str, endptr, radix)  
         char *str;  
         char **endptr;  
         int radix;  
 {  {
         u_quad_t num, num2;          u_quad_t num, num2;
         char *expr, *expr2;          char *expr, *expr2;
Line 734  erange:
Line 710  erange:
         return (UQUAD_MAX);          return (UQUAD_MAX);
 }  }
   
 static  static u_quad_t
 u_quad_t  strtolimit(char *str, char **endptr, int radix)
 strtolimit(str, endptr, radix)  
         char *str;  
         char **endptr;  
         int radix;  
 {  {
         if (isinfinite(str)) {          if (isinfinite(str)) {
                 if (endptr)                  if (endptr)
Line 761  isinfinite(const char *s)
Line 733  isinfinite(const char *s)
         };          };
         const char **i;          const char **i;
   
         for(i = infs; *i; i++) {          for (i = infs; *i; i++) {
                 if (!strcasecmp(s, *i))                  if (!strcasecmp(s, *i))
                         return 1;                          return 1;
         }          }
Line 769  isinfinite(const char *s)
Line 741  isinfinite(const char *s)
 }  }
   
 static u_quad_t  static u_quad_t
 multiply(n1, n2)  multiply(u_quad_t n1, u_quad_t n2)
         u_quad_t n1;  
         u_quad_t n2;  
 {  {
         static int bpw = 0;          static int bpw = 0;
         u_quad_t m;          u_quad_t m;
Line 853  multiply(n1, n2)
Line 823  multiply(n1, n2)
   
         return (m);          return (m);
 }  }
   

Legend:
Removed from v.1.5  
changed lines
  Added in v.1.5.4.1

CVSweb <webmaster@jp.NetBSD.org>