home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / MULT_S.LHA / MultiUser / Src / Library / UserInfo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-07  |  3.7 KB  |  148 lines
  1. /************************************************************
  2. * MultiUser - MultiUser Task/File Support System                *
  3. * ---------------------------------------------------------    *
  4. * User Information Management                                            *
  5. * ---------------------------------------------------------    *
  6. * © Copyright 1993-1994 Geert Uytterhoeven                        *
  7. * All Rights Reserved.                                                    *
  8. ************************************************************/
  9.  
  10.  
  11. #include <proto/exec.h>
  12.  
  13. #include "Memory.h"
  14. #include "UserInfo.h"
  15. #include "Server.h"
  16.  
  17.  
  18.     /*
  19.      *        Allocate a UserInfo Structure
  20.      *
  21.      *        Public Library Function
  22.      */
  23.  
  24. struct muPrivUserInfo __asm __saveds *muAllocUserInfo(void)
  25. {
  26.     return(MAlloc(sizeof(struct muPrivUserInfo)));
  27. }
  28.  
  29.  
  30.     /*
  31.      *        Free a UserInfo Structure
  32.      *
  33.      *        Public Library Function
  34.      */
  35.  
  36. void __asm __saveds muFreeUserInfo(register __a0 struct muPrivUserInfo *info)
  37. {
  38.    if (info) {
  39.         if (info->Pub.NumSecGroups)
  40.            Free(info->Pub.SecGroups, info->Pub.NumSecGroups*sizeof(UWORD));
  41.       FreeV(info->Pattern);
  42.          Free(info, sizeof(struct muPrivUserInfo));
  43.     }
  44. }
  45.  
  46.  
  47.     /*
  48.      *        Get Information about a User
  49.      *
  50.      *        Public Library Function
  51.      */
  52.  
  53. struct muPrivUserInfo __asm __saveds *muGetUserInfo(register __a0 struct muPrivUserInfo *info,
  54.                                                                      register __d0 ULONG keytype)
  55. {
  56.     return((struct muPrivUserInfo *)SendServerPacket(muSAction_GetUserInfo, (LONG)info, keytype, NULL,
  57.                                                                      NULL));
  58. }
  59.  
  60.  
  61.     /*
  62.      *        Get the Relationship from a User to an Object
  63.      *
  64.      *        Public Library Function
  65.      */
  66.  
  67. ULONG __asm muGetRelationshipA(register __d0 struct muExtOwner *user, register __d1 ULONG owner,
  68.                                          register __a0 struct TagItem *taglist)
  69. {
  70.     ULONG flags;
  71.     UWORD useruid, usergid;
  72.     UWORD owneruid;
  73.  
  74.     if (user) {
  75.         useruid = user->uid;
  76.         usergid = user->gid;
  77.     } else
  78.         useruid = usergid = NULL;
  79.  
  80.     owneruid = (owner & muMASK_UID)>>16;
  81.     if (owneruid == muNOBODY_UID) {
  82.         if (useruid == muROOT_UID)
  83.             flags = muRelF_ROOT_UID | muRelF_ROOT_GID | muRelF_UID_MATCH | muRelF_GID_MATCH |
  84.                       muRelF_PRIM_GID | muRelF_NO_OWNER;
  85.         else if (useruid == muNOBODY_UID)
  86.             flags = muRelF_NOBODY | muRelF_UID_MATCH | muRelF_GID_MATCH | muRelF_PRIM_GID | muRelF_NO_OWNER;
  87.         else if (usergid == muROOT_GID)
  88.             flags = muRelF_ROOT_GID | muRelF_UID_MATCH | muRelF_GID_MATCH | muRelF_PRIM_GID |
  89.                       muRelF_NO_OWNER;
  90.         else
  91.             flags = muRelF_UID_MATCH | muRelF_GID_MATCH | muRelF_PRIM_GID | muRelF_NO_OWNER;
  92.     } else {
  93.         if (useruid == muROOT_UID)
  94.             flags = muRelF_ROOT_UID | muRelF_ROOT_GID | muRelF_UID_MATCH | muRelF_GID_MATCH |
  95.                       muRelF_PRIM_GID;
  96.         else if (useruid == muNOBODY_UID)
  97.             flags = muRelF_NOBODY;
  98.         else {
  99.             if (owneruid == useruid)
  100.                 flags = muRelF_UID_MATCH;
  101.             else
  102.                 flags = NULL;
  103.             if (usergid == muROOT_GID)
  104.                 flags |= muRelF_ROOT_GID | muRelF_GID_MATCH | muRelF_PRIM_GID;
  105.             else {
  106.                 UWORD ownergid = owner & muMASK_GID;
  107.                 if (ownergid == usergid)
  108.                     flags |= muRelF_GID_MATCH | muRelF_PRIM_GID;
  109.                 else if (user) {
  110.                     UWORD *sgids = muSecGroups(user);
  111.                     int i;
  112.                     for (i = 0; i < user->NumSecGroups; i++)
  113.                         if (ownergid == sgids[i]) {
  114.                             flags |= muRelF_GID_MATCH;
  115.                             break;
  116.                         }
  117.                 }
  118.             }
  119.         }
  120.     }
  121.     return(flags);
  122. }
  123.  
  124.  
  125.     /*
  126.      *        Convert a Public User Information Structure to an Extended Owner
  127.      *        Information Structure
  128.      *
  129.      *        Public Library Function
  130.      */
  131.  
  132. struct muExtOwner __asm __saveds *muUserInfo2ExtOwner(register __a0 struct muUserInfo *info)
  133. {
  134.     struct muExtOwner *owner = NULL;
  135.     ULONG size;
  136.  
  137.     if (info) {
  138.         size = info->NumSecGroups*sizeof(UWORD);
  139.         if (owner = (struct muExtOwner *)MAlloc(size+sizeof(struct muExtOwner))) {
  140.             owner->uid = info->uid;
  141.             owner->gid = info->gid;
  142.             owner->NumSecGroups = info->NumSecGroups;
  143.             CopyMem(info->SecGroups, muSecGroups(owner), size);
  144.         }
  145.     }
  146.     return(owner);
  147. }
  148.