home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Netzwerk / NETMU17.LHA / accounts / accounts.c next >
Encoding:
C/C++ Source or Header  |  1994-11-02  |  20.0 KB  |  862 lines
  1. /*
  2. **    $VER: accounts.c 1.6 (02.11.94)
  3. **
  4. **    accounts.library functions
  5. **
  6. **    © Copyright 1994 by Norbert Püschel
  7. **    All Rights Reserved
  8. */
  9.  
  10. #include <proto/exec.h>
  11. #include <proto/dos.h>
  12. #include <proto/multiuser.h>
  13. #include <clib/accounts_protos.h>
  14. #include <pragmas/accounts_pragmas.h>
  15. #include <clib/alib_protos.h>
  16.  
  17. #include <exec/memory.h>
  18. #include <exec/execbase.h>
  19. #include <dos/notify.h>
  20. #include <envoy/errors.h>
  21.  
  22. #include <string.h>
  23. #include "daemon.h"
  24. #include <debug.h>
  25.  
  26. #define NOBODY
  27.  
  28. #ifdef NOBODY
  29. const UBYTE nobody[] = "nobody";
  30.  
  31. #define NOBODYNAME (STRPTR)nobody
  32. #endif
  33.  
  34. #define BUFFLEN 256
  35. #define UNAMELEN 32
  36. #define GNAMELEN 32
  37. #define PWDLEN   16
  38.  
  39. extern struct Library *AccountsBase;
  40.  
  41. struct MinList         UserList;
  42. struct SignalSemaphore UserSemaphore;
  43. struct MinList         GroupList;
  44. struct SignalSemaphore GroupSemaphore;
  45.  
  46. struct InternalUserInfo {
  47.   struct MinNode  iui_Node;
  48.   struct UserInfo iui_UserInfo;
  49.   struct MinList  iui_SecGroups;
  50.   UBYTE           iui_CryptPasswd[PWDLEN];
  51. };
  52.  
  53. struct InternalGroupInfo {
  54.   struct MinNode   igi_Node;
  55.   struct GroupInfo igi_GroupInfo;
  56. };
  57.  
  58. struct SecGroup {
  59.   struct MinNode            sg_Node;
  60.   struct InternalGroupInfo *sg_IGI;
  61. };
  62.  
  63. void init_users(void)
  64.  
  65. {
  66.   NewList((struct List *)&UserList);
  67.   InitSemaphore(&UserSemaphore);
  68. }
  69.  
  70. void init_groups(void)
  71.  
  72. {
  73.   NewList((struct List *)&GroupList);
  74.   InitSemaphore(&GroupSemaphore);
  75. }
  76.  
  77. void free_users(void)
  78.  
  79. {
  80.   struct InternalUserInfo *iui;
  81.   struct SecGroup *sg;
  82.  
  83.   ObtainSemaphore(&UserSemaphore);
  84.   iui = (struct InternalUserInfo *)(UserList.mlh_Head);  
  85.   while(iui->iui_Node.mln_Succ) {
  86.     Remove((struct Node *)iui);
  87.     sg = (struct SecGroup *)(iui->iui_SecGroups.mlh_Head);
  88.     while(sg->sg_Node.mln_Succ) {
  89.       Remove((struct Node *)sg);
  90.       FreeMem(sg,sizeof(struct SecGroup));
  91.       sg = (struct SecGroup *)(iui->iui_SecGroups.mlh_Head);
  92.     }
  93.     FreeMem(iui,sizeof(struct InternalUserInfo));
  94.     iui = (struct InternalUserInfo *)(UserList.mlh_Head);  
  95.   }
  96.   ReleaseSemaphore(&UserSemaphore);  
  97. }
  98.  
  99. void free_groups(void)
  100.  
  101. {
  102.   struct InternalGroupInfo *igi;
  103.  
  104.   ObtainSemaphore(&GroupSemaphore);
  105.   igi = (struct InternalGroupInfo *)(GroupList.mlh_Head);  
  106.   while(igi->igi_Node.mln_Succ) {
  107.     Remove((struct Node *)igi);
  108.     FreeMem(igi,sizeof(struct InternalGroupInfo));
  109.     igi = (struct InternalGroupInfo *)(GroupList.mlh_Head);  
  110.   }
  111.   ReleaseSemaphore(&GroupSemaphore);  
  112. }
  113.  
  114. BOOL adduser(STRPTR uname,UWORD uid,UWORD gid,ULONG flags,STRPTR pwd)
  115.  
  116. {
  117.   struct InternalUserInfo *iui;
  118.  
  119.   iui = (struct InternalUserInfo *)
  120.         AllocMem(sizeof(struct InternalUserInfo),MEMF_PUBLIC);
  121.   if(iui) {
  122.     strncpy(iui->iui_UserInfo.ui_UserName,uname,UNAMELEN);
  123.     iui->iui_UserInfo.ui_UserID = uid;
  124.     iui->iui_UserInfo.ui_PrimaryGroupID = gid;
  125.     iui->iui_UserInfo.ui_Flags = flags;
  126.     strncpy(iui->iui_CryptPasswd,pwd,PWDLEN);
  127.     NewList((struct List *)&(iui->iui_SecGroups));
  128.     AddTail((struct List *)&UserList,(struct Node *)iui);
  129.   }
  130.   return((BOOL)(iui != 0));
  131. }
  132.  
  133. BOOL addgroup(STRPTR gname,UWORD gid)
  134.  
  135. {
  136.   struct InternalGroupInfo *igi;
  137.  
  138.   igi = (struct InternalGroupInfo *)
  139.         AllocMem(sizeof(struct InternalGroupInfo),MEMF_PUBLIC);
  140.   if(igi) {
  141.     strncpy(igi->igi_GroupInfo.gi_GroupName,gname,32);
  142.     igi->igi_GroupInfo.gi_GroupID = gid;
  143.     AddTail((struct List *)&GroupList,(struct Node *)igi);
  144.   }
  145.   return((BOOL)(igi != 0));
  146. }
  147.  
  148. BOOL addsecgroup(struct InternalUserInfo *iui,struct InternalGroupInfo *igi)
  149.  
  150. {
  151.   struct SecGroup *sg;
  152.  
  153.   sg = (struct SecGroup *)AllocMem(sizeof(struct SecGroup),MEMF_PUBLIC);
  154.   if(sg) {
  155.     sg->sg_IGI = igi;
  156.     AddTail((struct List *)&(iui->iui_SecGroups),(struct Node *)sg);
  157.   }
  158.   return((BOOL)(sg != 0));
  159. }
  160.  
  161. STRPTR nextsep(STRPTR s,UBYTE sep)
  162.  
  163. {
  164.   while(*s && *s != '\n' && *s != sep) s++;
  165.   return(s);
  166. }
  167.  
  168. struct InternalUserInfo *finduid(UWORD uid)
  169.  
  170. {
  171.   struct InternalUserInfo *iui;
  172.  
  173.   iui = (struct InternalUserInfo *)(UserList.mlh_Head);  
  174.   while(iui->iui_Node.mln_Succ) {
  175.     if(iui->iui_UserInfo.ui_UserID == uid) return(iui);
  176.     iui = (struct InternalUserInfo *)(iui->iui_Node.mln_Succ);  
  177.   }
  178.   return(0);
  179. }
  180.  
  181. struct InternalGroupInfo *findgid(UWORD gid)
  182.  
  183. {
  184.   struct InternalGroupInfo *igi;
  185.  
  186.   igi = (struct InternalGroupInfo *)(GroupList.mlh_Head);  
  187.   while(igi->igi_Node.mln_Succ) {
  188.     if(igi->igi_GroupInfo.gi_GroupID == gid) return(igi);
  189.     igi = (struct InternalGroupInfo *)(igi->igi_Node.mln_Succ);  
  190.   }
  191.   return(0);
  192. }
  193.  
  194. struct InternalUserInfo *finduname(STRPTR uname)
  195.  
  196. {
  197.   struct InternalUserInfo *iui;
  198.  
  199.   iui = (struct InternalUserInfo *)(UserList.mlh_Head);  
  200.   while(iui->iui_Node.mln_Succ) {
  201.     if(strcmp(iui->iui_UserInfo.ui_UserName,uname) == 0) return(iui);
  202.     iui = (struct InternalUserInfo *)(iui->iui_Node.mln_Succ);  
  203.   }
  204.   return(0);
  205. }
  206.  
  207. struct InternalGroupInfo *findgname(STRPTR gname)
  208.  
  209. {
  210.   struct InternalGroupInfo *igi;
  211.  
  212.   igi = (struct InternalGroupInfo *)(GroupList.mlh_Head);  
  213.   while(igi->igi_Node.mln_Succ) {
  214.     if(strcmp(igi->igi_GroupInfo.gi_GroupName,gname) == 0) return(igi);
  215.     igi = (struct InternalGroupInfo *)(igi->igi_Node.mln_Succ);  
  216.   }
  217.   return(0);
  218. }
  219.  
  220. struct InternalUserInfo *finduser(STRPTR uname,UWORD uid)
  221.  
  222. {
  223.   struct InternalUserInfo *iui;
  224.  
  225.   iui = (struct InternalUserInfo *)(UserList.mlh_Head);  
  226.   while(iui->iui_Node.mln_Succ) {
  227.     if(iui->iui_UserInfo.ui_UserID == uid &&
  228.        strcmp(iui->iui_UserInfo.ui_UserName,uname) == 0) return(iui);
  229.     iui = (struct InternalUserInfo *)(iui->iui_Node.mln_Succ);  
  230.   }
  231.   return(0);
  232. }
  233.  
  234. struct InternalGroupInfo *findgroup(STRPTR gname,UWORD gid)
  235.  
  236. {
  237.   struct InternalGroupInfo *igi;
  238.  
  239.   igi = (struct InternalGroupInfo *)(GroupList.mlh_Head);  
  240.   while(igi->igi_Node.mln_Succ) {
  241.     if(igi->igi_GroupInfo.gi_GroupID == gid &&
  242.       strcmp(igi->igi_GroupInfo.gi_GroupName,gname) == 0) return(igi);
  243.     igi = (struct InternalGroupInfo *)(igi->igi_Node.mln_Succ);  
  244.   }
  245.   return(0);
  246. }
  247.  
  248. BOOL issecmem(struct InternalUserInfo *iui,struct InternalGroupInfo *igi)
  249.  
  250. {
  251.   struct SecGroup *sg;
  252.  
  253.   sg = (struct SecGroup *)(iui->iui_SecGroups.mlh_Head);
  254.   while(sg->sg_Node.mln_Succ) {
  255.     if(sg->sg_IGI == igi) return(TRUE);
  256.     sg = (struct SecGroup *)(sg->sg_Node.mln_Succ);
  257.   }
  258.   return(FALSE);
  259. }
  260.  
  261. void read_users(void)
  262.  
  263. {
  264.   BPTR passwd;
  265.   UBYTE buff[BUFFLEN];
  266.   STRPTR s,pwd,uidstr,gidstr;
  267.   ULONG flags = 0;
  268.   LONG uid,gid;
  269.  
  270.   ObtainSemaphore(&UserSemaphore);
  271.  
  272. #ifdef NOBODY
  273.   if(!adduser(NOBODYNAME,0,0,0,"")) return;
  274. #endif
  275.  
  276.   passwd = Open(muPasswd_FileName,MODE_OLDFILE);
  277.   if(passwd) {
  278.     while(FGets(passwd,buff,BUFFLEN-1)) {
  279.       s = nextsep(buff,'|');
  280.       if(*s != '|') break;
  281.       *(s++) = '\0';
  282.       pwd = s;
  283.       s = nextsep(pwd,'|');
  284.       if(*s != '|') break;
  285.       if(s != pwd) flags = UFLAGF_NeedsPassword;
  286.       *(s++) = '\0';
  287.       uidstr = s;
  288.       s = nextsep(uidstr,'|');
  289.       if(*s != '|') break;
  290.       *(s++) = '\0';
  291.       gidstr = s;
  292.       s = nextsep(gidstr,'|');
  293.       if(*s != '|') break;
  294.       *s = '\0';
  295.  
  296.       if(StrToLong(uidstr,&uid) <= 0) break;
  297.       if(StrToLong(gidstr,&gid) <= 0) break;
  298.  
  299.       flags |= UFLAGF_AdminPassword; /* should evaluate config !!! */
  300.       if(uid == muROOT_UID) flags |= (UFLAGF_AdminGroups|UFLAGF_AdminAll);
  301.  
  302.       if(!adduser(buff,uid,gid,flags,pwd)) break;
  303.     }
  304.     Close(passwd);
  305.   }
  306.   ReleaseSemaphore(&UserSemaphore);
  307. }
  308.  
  309. void read_groups(void)
  310.  
  311. {
  312.   BPTR group;
  313.   UBYTE buff[BUFFLEN];
  314.   STRPTR s,gidstr;
  315.   LONG uid,gid;
  316.   struct InternalGroupInfo *igi;
  317.   struct InternalUserInfo *iui;
  318.   BOOL done;
  319.  
  320.   ObtainSemaphore(&UserSemaphore);
  321.   ObtainSemaphore(&GroupSemaphore);
  322.  
  323.   group = Open(muGroup_FileName,MODE_OLDFILE);
  324.   if(group) {
  325.     while(FGets(group,buff,BUFFLEN-1) && *buff != ' ' && *buff != '\n') {
  326.       s = nextsep(buff,'|');
  327.       if(*s != '|') break;
  328.       *(s++) = '\0';
  329.       gidstr = s;
  330.       s = nextsep(gidstr,'|');
  331.       if(*s != '|') break;
  332.       *s = '\0';
  333.  
  334.       if(StrToLong(gidstr,&gid) <= 0) break;
  335.  
  336.       if(!addgroup(buff,gid)) break;
  337.     }
  338.     while(FGets(group,buff,BUFFLEN-1)) { /* secondary groups */
  339.       s = nextsep(buff,':');
  340.       if(*s != ':') break;
  341.       *(s++) = '\0';
  342.       if(StrToLong(buff,&uid) <= 0) break;
  343.       iui = finduid(uid);
  344.       if(uid) {
  345.         do {
  346.           gidstr = s;
  347.           s = nextsep(gidstr,',');
  348.           done = (*s != ',');
  349.           *(s++) = '\0';
  350.           if(StrToLong(gidstr,&gid) <= 0) break;
  351.           igi = findgid(gid);
  352.           if(igi) {
  353.             if(!addsecgroup(iui,igi)) break;
  354.           }
  355.         } while(!done);
  356.       }
  357.     }
  358.     Close(group);
  359.   }
  360.   ReleaseSemaphore(&GroupSemaphore);
  361.   ReleaseSemaphore(&UserSemaphore);
  362. }
  363.  
  364. void __saveds guardian_func(void)
  365.  
  366. {
  367.   struct muBase *muBase;
  368.   struct NotifyRequest *passwd_req;
  369.   struct NotifyRequest *group_req;
  370.   BYTE passwd_sig,group_sig;
  371.   BPTR passwd_dir,olddir;  
  372.  
  373.   BOOL pok,gok;
  374.  
  375.   ULONG mask,rmask,pmask,gmask,emask;
  376.  
  377.   volatile struct Daemon *guardian;
  378.  
  379.   guardian = DaemonInit();
  380.  
  381.   if(DaemonOK(guardian)) {
  382.     init_users();
  383.     init_groups();
  384.  
  385.     muBase = (struct muBase *)OpenLibrary(MULTIUSERNAME,MULTIUSERVERSION);
  386.   
  387.     if(muBase) {
  388.       passwd_dir = muGetPasswdDirLock();
  389.       CloseLibrary((struct Library *)muBase);
  390.     }
  391.     else {
  392.       UBYTE buff[256];
  393.   
  394.       if(GetVar("PASSWDDIR",buff,256,0) != -1) {
  395.         passwd_dir = Lock(buff,SHARED_LOCK);
  396.       }
  397.       else {
  398.         passwd_dir = Lock("S:",SHARED_LOCK);
  399.       }
  400.     }
  401.   
  402.     if(passwd_dir) {
  403.       D(bug("Passwd dir found !\n"));
  404.       olddir = CurrentDir(passwd_dir);
  405.       passwd_sig = AllocSignal(-1);
  406.       if(passwd_sig != -1) {
  407.         group_sig = AllocSignal(-1);
  408.         if(group_sig != -1) {
  409.           D(bug("Signals allocated !\n"));
  410.           passwd_req = (struct NotifyRequest *)
  411.             AllocMem(sizeof(struct NotifyRequest),MEMF_PUBLIC|MEMF_CLEAR);        
  412.           if(passwd_req) {
  413.             group_req = (struct NotifyRequest *)
  414.               AllocMem(sizeof(struct NotifyRequest),MEMF_PUBLIC|MEMF_CLEAR);        
  415.             if(group_req) {
  416.               D(bug("Notifiers allocated !\n"));
  417.               passwd_req->nr_Name = muPasswd_FileName;
  418.               passwd_req->nr_Flags = NRF_SEND_SIGNAL;
  419.               passwd_req->nr_stuff.nr_Signal.nr_Task = FindTask(0);
  420.               passwd_req->nr_stuff.nr_Signal.nr_SignalNum = passwd_sig;
  421.  
  422.               group_req->nr_Name = muGroup_FileName;
  423.               group_req->nr_Flags = NRF_SEND_SIGNAL;
  424.               group_req->nr_stuff.nr_Signal.nr_Task = FindTask(0);
  425.               group_req->nr_stuff.nr_Signal.nr_SignalNum = group_sig;
  426.  
  427.               pok = StartNotify(passwd_req);
  428.               gok = StartNotify(group_req);
  429.  
  430.               read_users();
  431.               read_groups();
  432.  
  433.               DaemonInitOK(guardian);
  434.  
  435.               pmask = 1L << passwd_sig;
  436.               gmask = 1L << group_sig;
  437.               emask = 1L << DaemonSignal(guardian);
  438.               mask = pmask | gmask | emask;
  439.  
  440.               D(bug("Starting Loop !\n"));
  441.  
  442.               for(;;) {
  443.                 rmask = Wait(mask);
  444.  
  445.                 if(rmask & emask) break;
  446.                 if(rmask & pmask) {
  447.                   D(bug("New Users !\n"));
  448.                   ObtainSemaphore(&UserSemaphore);
  449.                   free_users();
  450.                   read_users();
  451.                   ReleaseSemaphore(&UserSemaphore);
  452.                 }
  453.                 if(rmask & gmask) {
  454.                   D(bug("New Groups !\n"));
  455.                   ObtainSemaphore(&GroupSemaphore);
  456.                   free_groups();
  457.                   read_groups();
  458.                   ReleaseSemaphore(&GroupSemaphore);
  459.                 }
  460.               }
  461.  
  462.               D(bug("Ending Loop !\n"));
  463.  
  464.               if(gok) EndNotify(group_req);
  465.               if(pok) EndNotify(passwd_req);
  466.  
  467.               FreeMem(group_req,sizeof(struct NotifyRequest));
  468.             }
  469.             FreeMem(passwd_req,sizeof(struct NotifyRequest));
  470.           }
  471.           FreeSignal(group_sig);
  472.         }
  473.         FreeSignal(passwd_sig);
  474.       }
  475.       UnLock(CurrentDir(olddir));
  476.     }
  477.    
  478.     D(bug("Freeing Userinfo ...\n"));
  479.     free_users();
  480.     D(bug("Freeing Groupinfo ...\n"));
  481.     free_groups();
  482.   }
  483.  
  484.   D(bug("Ending Guardian !\n"));
  485.   DaemonExit(guardian);
  486. }
  487.  
  488. /* allocation functions */
  489.  
  490. struct UserInfo * __saveds LIBAllocUserInfo(void)
  491.  
  492. {
  493.   D(bug("AllocUserInfo\n"));
  494.  
  495.   return((struct UserInfo *)AllocMem(sizeof(struct UserInfo),MEMF_CLEAR));
  496. }
  497.  
  498. struct GroupInfo * __saveds LIBAllocGroupInfo(void)
  499.  
  500. {
  501.   D(bug("AllocGroupInfo\n"));
  502.  
  503.   return((struct GroupInfo *)AllocMem(sizeof(struct GroupInfo),MEMF_CLEAR));
  504. }
  505.  
  506. void __saveds __asm LIBFreeUserInfo(register __a0 struct UserInfo *user)
  507.  
  508. {
  509.   D(bug("FreeUserInfo: Name: %s, UID: %ld\n",
  510.          user->ui_UserName,user->ui_UserID));
  511.  
  512.   FreeMem(user,sizeof(struct UserInfo));
  513. }
  514.  
  515.  
  516. void __saveds __asm LIBFreeGroupInfo(register __a0 struct GroupInfo *group)
  517.  
  518. {
  519.   D(bug("FreeGroupInfo: Name: %s, GID: %ld\n",
  520.          group->gi_GroupName,group->gi_GroupID));
  521.  
  522.   FreeMem(group,sizeof(struct GroupInfo));
  523. }
  524.  
  525. /* xxxToyyy functions */
  526.  
  527. ULONG __saveds __asm LIBNameToUser(register __a0 STRPTR uname,
  528.                                    register __a1 struct UserInfo *user)
  529.  
  530. {
  531.   ULONG retval;
  532.   struct InternalUserInfo *iui;
  533.  
  534.   D(bug("NameToUser\n"));
  535.  
  536.   ObtainSemaphoreShared(&UserSemaphore);
  537.  
  538. #ifdef NOBODY
  539.   if(stricmp(NOBODYNAME,uname) == 0) uname = NOBODYNAME; /* normalize */
  540. #endif
  541.  
  542.   iui = finduname(uname);
  543.  
  544.   if(iui) {
  545.     *user = iui->iui_UserInfo;
  546.     retval = 0;
  547.   }
  548.   else retval = ENVOYERR_UNKNOWNUSER;
  549.  
  550.   ReleaseSemaphore(&UserSemaphore);
  551.  
  552.   return(retval);
  553. }
  554.  
  555. ULONG __saveds __asm LIBNameToGroup(register __a0 STRPTR gname,
  556.                                     register __a1 struct GroupInfo *group)
  557.  
  558. {
  559.   ULONG retval;
  560.   struct InternalGroupInfo *igi;
  561.  
  562.   D(bug("NameToGroup\n"));
  563.  
  564.   ObtainSemaphoreShared(&GroupSemaphore);
  565.  
  566.   igi = findgname(gname);
  567.  
  568.   if(igi) {
  569.     *group = igi->igi_GroupInfo;
  570.     retval = 0;
  571.   }
  572.   else retval = ENVOYERR_UNKNOWNGROUP;
  573.  
  574.   ReleaseSemaphore(&GroupSemaphore);
  575.  
  576.   return(retval);
  577. }
  578.  
  579. ULONG __saveds __asm LIBIDToUser(register __d0 UWORD uid, 
  580.                                  register __a0 struct UserInfo *user)
  581.  
  582. {
  583.   ULONG retval;
  584.   struct InternalUserInfo *iui;
  585.  
  586.   D(bug("IDToUser\n"));
  587.  
  588.   ObtainSemaphoreShared(&UserSemaphore);
  589.  
  590.   iui = finduid(uid);
  591.  
  592.   if(iui) {
  593.     *user = iui->iui_UserInfo;
  594.     retval = 0;
  595.   }
  596.   else retval = ENVOYERR_UNKNOWNUSER;
  597.  
  598.   ReleaseSemaphore(&UserSemaphore);
  599.  
  600.   return(retval);
  601. }
  602.  
  603. ULONG __saveds __asm LIBIDToGroup(register __d0 UWORD gid,
  604.                                   register __a0 struct GroupInfo *group)
  605.  
  606. {
  607.   ULONG retval;
  608.   struct InternalGroupInfo *igi;
  609.  
  610.   D(bug("IDToGroup\n"));
  611.  
  612.   ObtainSemaphoreShared(&GroupSemaphore);
  613.  
  614.   igi = findgid(gid);
  615.  
  616.   if(igi) {
  617.     *group = igi->igi_GroupInfo;
  618.     retval = 0;
  619.   }
  620.   else retval = ENVOYERR_UNKNOWNGROUP;
  621.  
  622.   ReleaseSemaphore(&GroupSemaphore);
  623.  
  624.   return(retval);
  625. }
  626.  
  627. /* Nextxxx functions */
  628.  
  629. ULONG __saveds __asm LIBNextUser(register __a0 struct UserInfo *user)
  630.  
  631. {
  632.   ULONG retval = ENVOYERR_LASTUSER;
  633.   struct InternalUserInfo *iui;
  634.  
  635.   D(bug("NextUser\n"));
  636.  
  637.   ObtainSemaphoreShared(&UserSemaphore);
  638.  
  639.   if(user->ui_UserID != 0
  640. #ifdef NOBODY
  641.      || stricmp(user->ui_UserName,NOBODYNAME) == 0
  642. #endif
  643.     ) { /* take next */
  644.     iui = finduser(user->ui_UserName,user->ui_UserID);
  645.  
  646.     if(iui) iui = (struct InternalUserInfo *)(iui->iui_Node.mln_Succ);  
  647.     else retval = ENVOYERR_UNKNOWNUSER;
  648.   }
  649.   else { /* take first */   
  650.     iui = (struct InternalUserInfo *)(UserList.mlh_Head);  
  651.   }
  652.  
  653.   if(iui->iui_Node.mln_Succ) {
  654.     *user = iui->iui_UserInfo;
  655.     retval = 0;
  656.   }
  657.  
  658.   ReleaseSemaphore(&UserSemaphore);
  659.  
  660.   return(retval);
  661. }
  662.  
  663. ULONG __saveds __asm LIBNextGroup(register __a0 struct GroupInfo *group)
  664.  
  665. {
  666.   ULONG retval = ENVOYERR_LASTGROUP;
  667.   struct InternalGroupInfo *igi = 0;
  668.  
  669.   D(bug("NextGroup\n"));
  670.  
  671.   ObtainSemaphoreShared(&GroupSemaphore);
  672.  
  673.   if(group->gi_GroupID != 0 || ((igi = findgid(0)) != 0 && 
  674.      strcmp(igi->igi_GroupInfo.gi_GroupName,group->gi_GroupName) == 0)) {
  675.  
  676.     if(igi == 0) igi = findgroup(group->gi_GroupName,group->gi_GroupID);
  677.  
  678.     if(igi) igi = (struct InternalGroupInfo *)(igi->igi_Node.mln_Succ);  
  679.     else retval = ENVOYERR_UNKNOWNGROUP;
  680.   }
  681.   else { /* take first */   
  682.     igi = (struct InternalGroupInfo *)(GroupList.mlh_Head);  
  683.   }
  684.  
  685.   if(igi->igi_Node.mln_Succ) {
  686.     *group = igi->igi_GroupInfo;
  687.     retval = 0;
  688.   }
  689.  
  690.   ReleaseSemaphore(&GroupSemaphore);
  691.  
  692.   return(retval);
  693. }
  694.  
  695. ULONG __saveds __asm LIBNextMember(register __a0 struct GroupInfo *group,
  696.                                    register __a1 struct UserInfo *user)
  697.  
  698. {
  699.   ULONG retval = ENVOYERR_LASTMEMBER;
  700.   struct InternalUserInfo *iui;
  701.   struct InternalGroupInfo *igi;
  702.  
  703.   D(bug("NextMember\n"));
  704.  
  705.   ObtainSemaphoreShared(&UserSemaphore);
  706.   ObtainSemaphoreShared(&GroupSemaphore);
  707.  
  708.   if(group->gi_GroupID) {
  709.     igi = findgid(group->gi_GroupID);
  710.   }
  711.   else {
  712.     igi = findgname(group->gi_GroupName);
  713.     if(igi == 0) igi = findgid(0);
  714.   }
  715.   if(igi) {
  716.     *group = igi->igi_GroupInfo;
  717.  
  718.     if(user->ui_UserID != 0
  719. #ifdef NOBODY
  720.        || stricmp(user->ui_UserName,NOBODYNAME) == 0
  721. #endif
  722.       ) { /* takenext */
  723.  
  724.       iui = finduser(user->ui_UserName,user->ui_UserID);
  725.  
  726.       if(iui) iui = (struct InternalUserInfo *)(iui->iui_Node.mln_Succ);  
  727.       else retval = ENVOYERR_UNKNOWNUSER;
  728.     }
  729.     else { /* take first */   
  730.       iui = (struct InternalUserInfo *)(UserList.mlh_Head);  
  731.     }
  732.     
  733.     while(iui->iui_Node.mln_Succ) {
  734.       if(iui->iui_UserInfo.ui_PrimaryGroupID == group->gi_GroupID ||
  735.          issecmem(iui,igi)) break;
  736.       iui = (struct InternalUserInfo *)(iui->iui_Node.mln_Succ);  
  737.     }
  738.  
  739.     if(iui->iui_Node.mln_Succ) {
  740.       *user = iui->iui_UserInfo;
  741.       retval = 0;
  742.     }
  743.   }
  744.   else retval = ENVOYERR_UNKNOWNGROUP;
  745.     
  746.   ReleaseSemaphore(&GroupSemaphore);
  747.   ReleaseSemaphore(&UserSemaphore);
  748.  
  749.   return(retval);
  750. }
  751.  
  752. /* memberof */
  753.  
  754. ULONG __saveds __asm LIBMemberOf(register __a0 struct GroupInfo *group,
  755.                                  register __a1 struct UserInfo *user)
  756.  
  757. {
  758.   ULONG retval = ENVOYERR_UNKNOWNMEMBER;
  759.   struct InternalUserInfo *iui;
  760.   struct InternalGroupInfo *igi;
  761.  
  762.   D(bug("MemberOf\n"));
  763.  
  764.   ObtainSemaphoreShared(&UserSemaphore);
  765.   ObtainSemaphoreShared(&GroupSemaphore);
  766.  
  767.   if(user->ui_UserID) {
  768.     iui = finduid(user->ui_UserID);
  769.   }
  770.   else {
  771.     iui = finduname(user->ui_UserName);
  772. #ifdef NOBODY
  773.     if(iui == 0) iui = finduid(0);
  774. #endif
  775.   }
  776.   if(iui) {
  777.     *user = iui->iui_UserInfo;
  778.  
  779.     if(group->gi_GroupID) {
  780.       igi = findgid(group->gi_GroupID);
  781.     }
  782.     else {
  783.       igi = findgname(group->gi_GroupName);
  784.       if(igi == 0) igi = findgid(0);
  785.     }
  786.     if(igi) {
  787.       *group = igi->igi_GroupInfo;
  788.       if(user->ui_PrimaryGroupID == group->gi_GroupID || issecmem(iui,igi)) {
  789.         retval = 0;
  790.       }
  791.     }
  792.     else retval = ENVOYERR_UNKNOWNGROUP;
  793.   }
  794.   else retval = ENVOYERR_UNKNOWNUSER;
  795.  
  796.   ReleaseSemaphore(&GroupSemaphore);
  797.   ReleaseSemaphore(&UserSemaphore);
  798.  
  799.   D(bug("MemberOf-result: %ld\n",retval));
  800.  
  801.   return(retval);
  802. }
  803.  
  804. /* encryption & verification */
  805.  
  806. STRPTR __saveds __asm LIBECrypt(register __a0 STRPTR buff,
  807.                                 register __a1 STRPTR passwd,
  808.                                 register __a2 STRPTR uname)
  809.  
  810. {
  811.   D(bug("ECrypt: Name: %s, Pwd: %s\n",uname,passwd)); 
  812.  
  813.   return(ACrypt(buff,passwd,uname));
  814. }
  815.  
  816. ULONG __saveds __asm LIBVerifyUser(register __a0 STRPTR uname,
  817.                                    register __a1 STRPTR passwd,
  818.                                    register __a2 struct UserInfo *user)
  819.  
  820. {
  821.   UBYTE buff[16];
  822.  
  823.   D(bug("VerifyUser: Name: %s, Pwd: %s\n",uname,passwd));
  824.  
  825.   if(ACrypt(buff,passwd,uname)) {
  826.     return(VerifyUserCrypt(uname,buff,user));
  827.   }
  828.   else {
  829.     return(ENVOYERR_NORESOURCES);
  830.   }
  831. }
  832.  
  833. ULONG __saveds __asm LIBVerifyUserCrypt(register __a0 STRPTR uname,
  834.                                         register __a1 STRPTR passwd,
  835.                                         register __a2 struct UserInfo *user)
  836.  
  837. {
  838.   ULONG retval = ENVOYERR_UNKNOWNUSER;
  839.   struct InternalUserInfo *iui;
  840.  
  841.   D(bug("VerifyUserCrypt: Name: %s, Pwd: %s\n",uname,passwd));
  842.  
  843.   ObtainSemaphoreShared(&UserSemaphore);
  844.  
  845. #ifdef NOBODY
  846.   if(stricmp(NOBODYNAME,uname) == 0) uname = NOBODYNAME; /* normalize */
  847. #endif
  848.  
  849.   iui = finduname(uname);
  850.   if(iui && (iui->iui_CryptPasswd[0] == '\0' ||
  851.      strcmp(iui->iui_CryptPasswd,passwd) == 0)) {
  852.     *user = iui->iui_UserInfo;
  853.     retval = 0;
  854.   }
  855.  
  856.   ReleaseSemaphore(&UserSemaphore);
  857.  
  858.   D(bug("VerifyUserCrypt: %ld\n",retval));
  859.  
  860.   return(retval);
  861. }
  862.