home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume26 / screen-3.5 / part02 / acl.c next >
C/C++ Source or Header  |  1993-07-25  |  11KB  |  479 lines
  1. /* Copyright (c) 1993
  2.  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
  3.  *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
  4.  * Copyright (c) 1987 Oliver Laumann
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2, or (at your option)
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program (see the file COPYING); if not, write to the
  18.  * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  ****************************************************************
  21.  */
  22. #include "rcs.h"
  23. RCS_ID("$Id: acl.c,v 1.5 1993/07/16 14:04:12 mlschroe Exp $ FAU")
  24.  
  25. #include "config.h"
  26. #include "screen.h"    /* includes acl.h */
  27. #include "extern.h"
  28.  
  29.  
  30. /************************************************************************
  31.  * user managing code, this does not really belong into the acl stuff   *
  32.  ************************************************************************/
  33.  
  34. extern struct comm comms[];
  35. extern struct win *windows, *wtab[];
  36. extern struct display *display, *displays;
  37. static struct user *userroot;
  38.  
  39. #ifdef MULTIUSER
  40. /* record given user ids here */
  41. static AclBits userbits;
  42.  
  43. /* rights a new unknown user will have on windows and cmds */
  44. static char default_w_bit[ACL_BITS_PER_WIN] = 
  45. { 
  46.   1,    /* EXEC */
  47.   1,     /* WRITE */
  48.   1     /* READ */
  49. };
  50.  
  51. static char default_c_bit[ACL_BITS_PER_CMD] = 
  52. { 
  53.   1    /* EXEC */
  54. };
  55.  
  56. /* rights of all users per newly created window */
  57. static AclBits default_w_userbits[ACL_BITS_PER_WIN];
  58.  
  59. /*
  60. static AclBits default_c_userbits[ACL_BITS_PER_CMD];
  61. */
  62.  
  63. static int maxusercount = 0;
  64.  
  65. static int GrowBitfield __P((AclBits *, int, int, int));
  66.  
  67.  
  68.  
  69. static int
  70. GrowBitfield(bfp, len, delta, defaultbit)
  71. AclBits *bfp;
  72. int len, delta, defaultbit;
  73. {
  74.   AclBits n, o = *bfp;
  75.   int i;
  76.  
  77.   if (!(n = (AclBits)calloc(1, (unsigned long)(&ACLBYTE((char *)0, len + delta + 1)))))
  78.     return -1;
  79.   for (i = 0; i < (len + delta); i++)
  80.     {
  81.       if (((i <  len) && (ACLBIT(i) & ACLBYTE(o, i))) ||
  82.           ((i >= len) && (defaultbit)))
  83.     ACLBYTE(n, i) |= ACLBIT(i);
  84.     }
  85.   if (len)
  86.     free(o);
  87.   *bfp = n;
  88.   return 0;
  89. }
  90.  
  91. #endif /* MULTIUSER */
  92.  
  93. /* 
  94.  * Returns an nonzero Address. Its contents is either a User-ptr, 
  95.  * or NULL which may be replaced by a User-ptr to create the entry.
  96.  */
  97. struct user **
  98. FindUserPtr(name)
  99. char *name;
  100. {
  101.   struct user **u;
  102.  
  103.   for (u = &userroot; *u; u = &(*u)->u_next)
  104.     if (!strcmp((*u)->u_name, name))
  105.       break;
  106. #ifdef MULTIUSER
  107.   debug3("FindUserPtr %s %sfound, id %d\n", name, (*u)?"":"not ", 
  108.          (*u)?(*u)->id:-1);
  109. #else
  110.   debug2("FindUserPtr %s %sfound\n", name, (*u)?"":"not ");
  111. #endif
  112.   return u;
  113. }
  114.  
  115. /*
  116.  * Add a new user. His password may be NULL or "" if none. 
  117.  * He is in no groups and thus has no rights.
  118.  */
  119. int
  120. UserAdd(name, pass, up)
  121. char *name, *pass;
  122. struct user **up;
  123. {
  124.   if (!up)
  125.     up = FindUserPtr(name);
  126.   if (*up)
  127.     return 1;        /* he is already there */
  128.   *up = (struct user *)calloc(1, sizeof(struct user));
  129.   if (!*up)
  130.     return -1;        /* he still does not exist */
  131.   strncpy((*up)->u_name, name, 20);
  132.   if (pass)
  133.     strncpy((*up)->u_password, pass, 20);
  134.  
  135. #ifdef MULTIUSER
  136.   /* now find an unused index */
  137.   for ((*up)->id = 0; (*up)->id < maxusercount; (*up)->id++)
  138.     if (!(ACLBIT((*up)->id) & ACLBYTE(userbits, (*up)->id)))
  139.       break;
  140.   debug2("UserAdd %s id %d\n", name, (*up)->id);
  141.   if ((*up)->id == maxusercount)
  142.     {
  143.       int i, j;
  144.       struct win *w;
  145.  
  146.       debug2("growing all bitfields %d += %d\n", maxusercount, USER_CHUNK);
  147.       /* the bitfields are full, grow a chunk */
  148.       /* first, the used_uid_indicator: */
  149.       if (GrowBitfield(&userbits, maxusercount, USER_CHUNK, 0))
  150.         {
  151.       free(*up); *up = NULL; return -1;
  152.     }
  153.       /* second, default command bits  */
  154.       /* (only if we generate commands dynamically) */
  155. /*
  156.       for (j = 0; j < ACL_BITS_PER_CMD; j++)
  157.     if (GrowBitfield(&default_c_userbits[j], maxusercount, USER_CHUNK, 
  158.         default_c_bit[j]))
  159.       {
  160.         free(*up); *up = NULL; return -1;
  161.       }
  162. */
  163.       /* third, the bits for each commands */
  164.       for (i = 0; i <= RC_LAST; i++)
  165.         for (j = 0; j < ACL_BITS_PER_CMD; j++)
  166.       if (GrowBitfield(&comms[i].userbits[j], maxusercount, USER_CHUNK,
  167.           default_c_bit[j]))
  168.         {
  169.           free(*up); *up = NULL; return -1;
  170.         }
  171.       /* fourth, default window and bits */
  172.       for (j = 0; j < ACL_BITS_PER_WIN; j++)
  173.     if (GrowBitfield(&default_w_userbits[j], maxusercount, USER_CHUNK,
  174.         default_w_bit[j]))
  175.       {
  176.         free(*up); *up = NULL; return -1;
  177.       }
  178.       /* fifth, the bits for each window */
  179.       for (w = windows; w; w = w->w_next)
  180.         for (j = 0; j < ACL_BITS_PER_WIN; j++)
  181.       if (GrowBitfield(&w->w_userbits[j], maxusercount, USER_CHUNK,
  182.           default_w_bit[j]))
  183.         {
  184.           free(*up); *up = NULL; return -1;
  185.         }
  186.       maxusercount += USER_CHUNK;
  187.     }
  188.   ACLBYTE(userbits, (*up)->id) |= ACLBIT((*up)->id);    
  189. #else /* MULTIUSER */
  190.   debug1("UserAdd %s\n", name);
  191. #endif /* MULTIUSER */
  192.   return 0;
  193. }
  194.  
  195. /* change user's password */
  196. int 
  197. UserSetPass(name, pass, up)
  198. char *name, *pass;
  199. struct user **up;
  200. {
  201.   if (!up)
  202.     up = FindUserPtr(name);
  203.   if (!*up)
  204.     return UserAdd(name, pass, up);
  205.   strncpy((*up)->u_password, pass ? pass : "", 20);
  206.   (*up)->u_password[20] = '\0';
  207.   return 0;
  208. }
  209.  
  210. /* 
  211.  * Remove a user from the list. 
  212.  * Decrease reference count of all his groups
  213.  * Free his grouplist.
  214.  */
  215. int 
  216. UserDel(name, up)
  217. char *name;
  218. struct user **up;
  219. {
  220.   struct user *u;
  221.   struct display *old, *next;
  222.  
  223.   if (!up)
  224.     up = FindUserPtr(name);
  225.   if (!(u = *up))
  226.     return -1;            /* he who does not exist cannot be removed */
  227.   old = display;
  228.   for (display = displays; display; display = next)
  229.     {
  230.       next = display->_d_next;
  231.       if (d_user != u)
  232.     continue;
  233.       if (display == old)
  234.     old = 0;
  235.       Detach(D_REMOTE);
  236.     }
  237.   display = old;
  238.   *up = u->u_next;
  239. #ifdef MULTIUSER
  240.   ACLBYTE(userbits, u->id) &= ~ACLBIT(u->id);
  241.   AclSetPerm(u, "-rwx", "#?");
  242. #endif
  243.   debug1("FREEING user structure for %s\n", u->u_name);
  244.   free(u);
  245.   return 0;
  246. }
  247.  
  248. /************************************************************************
  249.  *                     end of user managing code                        *
  250.  ************************************************************************/
  251.  
  252.  
  253. #ifdef MULTIUSER
  254.  
  255. extern char *multi;    /* username */
  256.  
  257. /* This gives the users default rights to the new window */
  258. int
  259. NewWindowAcl(w)
  260. struct win *w;
  261. {
  262.   int i, j;
  263.  
  264.   debug1("NewWindowAcl default_w_userbits for window %d\n", w->w_number);
  265.   for (j = 0; j < ACL_BITS_PER_WIN; j++)
  266.     {
  267.       /* we start with len 0 for the new bitfield size and add maxusercount */
  268.       if (GrowBitfield(&w->w_userbits[j], 0, maxusercount, 0))
  269.     {
  270.       while (--j >= 0)
  271.         free(w->w_userbits[j]);
  272.       return -1;
  273.     }
  274.       for (i = 0; i < maxusercount; i++)
  275.         if (ACLBIT(i) & ACLBYTE(default_w_userbits[j], i))
  276.       ACLBYTE(w->w_userbits[j], i) |= ACLBIT(i);
  277.     }
  278.   return 0;
  279. }
  280.  
  281. /* if mode starts with '-' we remove the users exec bit for cmd */
  282. int
  283. AclSetPermCmd(u, mode, cmd)
  284. struct user *u;
  285. char *mode;
  286. struct comm *cmd;
  287. {
  288.   int neg = 0;
  289.  
  290.   if (!multi)
  291.     return 0;
  292.   debug3("AclSetPermCmd %s %s %s\n", u->u_name, mode, cmd->name);
  293.   while (*mode)
  294.     {
  295.       switch (*mode++)
  296.         {
  297.     case '-': 
  298.       neg = 1;
  299.       continue;
  300.         case '+':
  301.       neg = 0;
  302.       continue;
  303.         case 'e': 
  304.         case 'x': 
  305.       if (neg)
  306.         ACLBYTE(cmd->userbits[ACL_EXEC], u->id) &= ~ACLBIT(u->id);
  307.       else
  308.         ACLBYTE(cmd->userbits[ACL_EXEC], u->id) |= ACLBIT(u->id);
  309.       break;
  310.         case 'r':
  311.     case 'w':
  312.       break;
  313.         default:
  314.       return -1;
  315.     }
  316.     }
  317.   return 0;
  318. }
  319.  
  320. /* mode strings of the form +rwx -w+rx r -wx are parsed and evaluated */
  321. int
  322. AclSetPermWin(u, mode, win)
  323. struct user *u;
  324. char *mode;
  325. struct win *win;
  326. {
  327.   int neg = 0;
  328.   int bit;
  329.  
  330.   if (!multi)
  331.     return 0;
  332.   debug3("AclSetPermWin %s %s %d\n", u->u_name, mode, win->w_number);
  333.   while (*mode)
  334.     {
  335.       switch (*mode++)
  336.         {
  337.     case '-': 
  338.       neg = 1;
  339.       continue;
  340.         case '+':
  341.       neg = 0;
  342.       continue;
  343.         case 'r': 
  344.       bit = ACL_READ;
  345.       break;
  346.     case 'w':
  347.       bit = ACL_WRITE;
  348.       break;
  349.         case 'x':
  350.       bit = ACL_EXEC;
  351.       break;
  352.     default:
  353.       return -1;
  354.         }
  355.       if (neg)
  356.     ACLBYTE(win->w_userbits[bit], u->id) &= ~ACLBIT(u->id);
  357.       else
  358.     ACLBYTE(win->w_userbits[bit], u->id) |= ACLBIT(u->id);
  359.     }
  360.   return 0;
  361. }
  362.  
  363. /* string is broken down into comand and window names, mode applies */
  364. int
  365. AclSetPerm(u, mode, s)
  366. struct user *u;
  367. char *mode, *s;
  368. {
  369.   struct win *w;
  370.   int i;
  371.   char *p;
  372.  
  373.   while (*s)
  374.     {
  375.       switch (*s)
  376.     {
  377.     case '*':    /* all windows and all commands */
  378.       return AclSetPerm(u, mode, "#?");
  379.     case '#':    /* all windows */
  380.       for (w = windows; w; w = w->w_next)
  381.         AclSetPermWin(u, mode, w);
  382.       s++;
  383.       break;
  384.     case '?':    /* all windows and all commands */
  385.       for (i = 0; i <= RC_LAST; i++)
  386.         AclSetPermCmd(u, mode, &comms[i]);
  387.       s++;
  388.       break;
  389.     default:
  390.       for (p = s; *p && *p != ' ' && *p != '\t' && *p != ','; p++)
  391.         ;
  392.       if (*p)
  393.         *p++ = '\0';
  394.       else
  395.         *p = '\0';
  396.       if ((i = FindCommnr(s)) != RC_ILLEGAL)
  397.         AclSetPermCmd(u, mode, &comms[i]);
  398.       else if (((i = WindowByNoN(s)) >= 0) && wtab[i])
  399.         AclSetPermWin(u, mode, wtab[i]);
  400.       else
  401.         /* checking group name */
  402.         return -1;
  403.       s = p; 
  404.     }    
  405.     }
  406.   return 0;
  407. }
  408.  
  409. #if 0
  410. void
  411. AclWinSwap(a, b)
  412. int a, b;
  413. {
  414.   int a_bit = 0, b_bit = 0;
  415.   AclGroupList **g;
  416.   AclBits p;
  417.  
  418.   debug2("acl lists swapping windows %d and %d\n", a, b);
  419.   
  420.   for (g = &aclgrouproot; *g; g = &(*g)->next) 
  421.     {
  422.       p = (*g)->group->winbits;
  423.       /* see if there was a bit for window a. zap it */
  424.       if (a >= 0)
  425.     if ((a_bit = ACLBIT(a) & ACLBYTE(p, a)))
  426.       ACLBYTE(p, a) &= ~ACLBIT(a);
  427.       /* see if there was a bit for window b. zap it */
  428.       if (b >= 0)
  429.     if ((b_bit = ACLBIT(b) & ACLBYTE(p, b)))
  430.       ACLBYTE(p, b) &= ~ACLBIT(b);
  431.       /* b may cause a set */
  432.       if (b_bit && a >= 0)
  433.         ACLBYTE(p, a) |= ACLBIT(a);
  434.       /* a may cause b set */
  435.       if (a_bit && b >= 0)
  436.         ACLBYTE(p, b) |= ACLBIT(b);
  437.     }
  438. }
  439. #else
  440. void
  441. AclWinSwap(a, b)
  442. int a, b;
  443. {
  444.   debug2("AclWinSwap(%d, %d) DUMMY\n", a, b);
  445. }
  446. #endif
  447.  
  448. int 
  449. AclCheckPermWin(u, mode, w)
  450. struct user *u;
  451. int mode;
  452. struct win *w;
  453. {
  454.   if (!multi)
  455.     return 0;
  456.   if (mode < 0 || mode >= ACL_BITS_PER_WIN)
  457.     return -1;
  458.   debug3("AclCheckPermWin(%s, %d, %d) = ", u->u_name, mode, w->w_number);
  459.   debug1("%d\n", !(ACLBYTE(w->w_userbits[mode], u->id) & ACLBIT(u->id)));
  460.   return         !(ACLBYTE(w->w_userbits[mode], u->id) & ACLBIT(u->id));
  461. }
  462.  
  463. int 
  464. AclCheckPermCmd(u, mode, c)
  465. struct user *u;
  466. int mode;
  467. struct comm *c;
  468. {
  469.   if (!multi)
  470.     return 0;
  471.   if (mode < 0 || mode >= ACL_BITS_PER_CMD)
  472.     return -1;
  473.   debug3("AclCheckPermCmd(%s %d %s) = ", u->u_name, mode, c->name); 
  474.   debug1("%d\n", !(ACLBYTE(c->userbits[mode], u->id) & ACLBIT(u->id)));
  475.   return         !(ACLBYTE(c->userbits[mode], u->id) & ACLBIT(u->id));
  476. }
  477.  
  478. #endif /* MULTIUSER */
  479.