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