home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PROGRAMS / UTILS / NOVELL / GRP.ZIP / USERS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-11-25  |  10.6 KB  |  461 lines
  1. /**********************************************************
  2.  * users.c
  3.  * version 2.0 - list users full name
  4.  * version 2.1 - added switch and group info
  5.  */
  6.  
  7. /*************************************************************
  8.  * usage:
  9.  *  users           - lists all members
  10.  *  users  /a       - lists all members and their info
  11.  *  users user name - lists info on a member
  12.  */
  13.  
  14.  
  15. #include <stdio.h>
  16. #include <dos.h>
  17. #include <ctype.h>
  18.  
  19. char myname[] = "Patrick L. McGillan";
  20. char mydate[] = "November 24, 1989";
  21. char myvers[] = "Users Version 2.1";
  22.  
  23. struct REGPACK Regs;
  24.  
  25. typedef unsigned char BYTE;
  26.  
  27. typedef struct {
  28.          unsigned char ah, al, bh, bl;
  29.                } LONG;
  30.  
  31. typedef struct {
  32.          char wh, wl;
  33.                } WORD;
  34.  
  35. typedef struct {
  36.          char wl, wh;
  37.                } NATIVE;
  38.  
  39. typedef struct {                    /* send packet format for e3(36h)    */
  40.          NATIVE SL;         /* packet length                    */
  41.                  BYTE   FNC;          /*  $36 for get object name      */
  42.          LONG   UOID;       /*  Unique ID for the object     */
  43.                } e336cl;
  44.  
  45. typedef struct {                    /* return packet format for e3(36h)    */
  46.          NATIVE RL;         /* return length                */
  47.          LONG   UOID;       /*  same id as above                */
  48.          WORD   OT;         /*  type of object                  */
  49.          BYTE   ON[48];
  50.                } e336rp;
  51.  
  52. typedef struct {                    /* send packet format for e3(46h)   */
  53.          NATIVE SL;         /* send packet length               */
  54.          BYTE   FNC;        /*  $46 = get  bindery access level */
  55.                } chkcall;
  56.  
  57. typedef struct {                    /* return packet format for e3(36h) */
  58.          NATIVE RL;         /* return length                    */
  59.                  BYTE   AL;         /* access level allowed             */
  60.          LONG   MOID;       /* My Object ID                     */
  61.                } chkrply;
  62.  
  63. typedef struct {                    /* send packet format for e3(37h)   */
  64.          NATIVE SL;         /* send packet length               */
  65.          BYTE   FNC;        /*  55 for Search for Users         */
  66.          LONG   LOS;        /*  make it -1                      */
  67.          WORD   PT;         /*  Search for users 0001           */
  68.          BYTE   PL;         /*  1                               */
  69.          BYTE   SP[48];     /*  *, if search all is used        */
  70.                } e33dcall;
  71.  
  72. typedef struct {                    /* return packet format for e3(37h) */
  73.          NATIVE RL;         /* return packet length             */
  74.          LONG   UOID;       /* unique object id code            */
  75.          WORD   OT;         /* object type                      */
  76.          BYTE   ON[48];     /* object name                      */
  77.                  BYTE   OF;         /* objects flags                    */
  78.                  BYTE   OS;         /* objects security                 */
  79.                  BYTE   PE;         /* properties exist                 */
  80.              }  e33drply;
  81.  
  82. typedef struct {                    /* send packet format for e3(3dh)   */
  83.          NATIVE SL;         /* send packet length               */
  84.          BYTE   FNC;        /* 55 for Search for Users          */
  85.          WORD   OT;         /* object type                      */
  86.          BYTE   ONL;        /* object name length               */
  87.          BYTE   ON[48];     /* object name                      */
  88.                  BYTE   SN;         /* segment number                   */
  89.                  BYTE   PNL;        /* property name length             */
  90.          BYTE   PN[48];     /* property name                    */
  91.                } e33prvcall;
  92.  
  93. typedef struct {                    /* return packet format for e3(3dh) */
  94.          NATIVE RL;         /* return packet length             */
  95.          BYTE   DT[128];    /* data                             */
  96.                  BYTE   MR;         /* more                             */
  97.                  BYTE   PF;         /* property flags                   */
  98.              }  e33prvrply;
  99.  
  100.  
  101. typedef struct {                    /* send packet format for e3(36h)   */
  102.                  NATIVE SL;
  103.                  BYTE   FNC;
  104.                  LONG   UOID;
  105.                } e33gncall;
  106.  
  107.  
  108. typedef struct {
  109.                  NATIVE RL;
  110.                  LONG   UOID;
  111.                  WORD   OT;
  112.                  BYTE   ON[48];
  113.                } e33gnrply;
  114.  
  115. e33gncall   gnc;
  116. e33gnrply   gnr;
  117.  
  118. e336cl       nc;
  119. e336rp       nr;
  120.  
  121. chkcall      cc;
  122. chkrply      cr;
  123.  
  124. e33dcall     pc;
  125. e33drply     pr;
  126.  
  127. e33prvcall   vc;
  128. e33prvrply   vr;
  129.  
  130. void Users (nam)
  131. char *nam;
  132. {
  133.     unsigned int SBO;
  134.     int     i, once = 0, first = 1, all = 0;
  135.  
  136.     if (strlen(nam) < 1)
  137.         strcpy (nam, "*");
  138.     else
  139.     {
  140.         all = 1;
  141.         once = 1;
  142.     }
  143.  
  144.     if ((strcmp("/a", nam) == 0) || (strcmp("/A", nam) == 0))
  145.     {
  146.         strcpy (nam, "*");
  147.         all = 1;
  148.         once = 0;
  149.     }
  150.  
  151.     do
  152.     {
  153.         SBO = scan_bind(first, nam);
  154.         if ((SBO & 0x00ff) == 0)
  155.         {
  156.             printf ("\n\n%s", pr.ON);
  157.             for (i=(12-strlen(pr.ON));i>0;--i)
  158.                 printf (" ");
  159.             prntbyt (pr.UOID.ah);
  160.             prntbyt (pr.UOID.al);
  161.             prntbyt (pr.UOID.bh);
  162.             prntbyt (pr.UOID.bl);
  163.             print_name (pr.ON);
  164.             if (all)
  165.                 tell_all (pr.ON);
  166.         }
  167.         first = 0;
  168.     } while (((SBO & 0x00ff) == 0) && (!once));
  169. }
  170.  
  171.  
  172. scan_bind (first, nam)
  173. int first;
  174. char *nam;
  175. {
  176.     if (first)
  177.     {
  178.         pc.LOS.ah = 0x1f;   /*  set the last object seen to -1  */
  179.         pc.LOS.al = 0xff;
  180.         pc.LOS.bh = 0xff;
  181.         pc.LOS.bl = 0xff;
  182.     }
  183.     else
  184.     {
  185.         pc.LOS.ah = pr.UOID.ah;   /*  set the last object seen to   */
  186.         pc.LOS.al = pr.UOID.al;   /*  the last object seen */
  187.         pc.LOS.bh = pr.UOID.bh;
  188.         pc.LOS.bl = pr.UOID.bl;
  189.     }
  190.             
  191.     pr.RL.wh = 0;
  192.     pr.RL.wl = 57;
  193.  
  194.     pc.SL.wh = 0;
  195.     pc.SL.wl = 58;
  196.  
  197.     pc.FNC = 0x37;   /*  scan bindery objects  */
  198.  
  199.     pc.PT.wh = 0;
  200.     pc.PT.wl = 1;
  201.  
  202.     pc.PL = 48;
  203.  
  204.     strcpy (pc.SP, nam);
  205.  
  206.     Regs.r_ax = 0xE300;
  207.  
  208.     Regs.r_es = FP_SEG (&pr);
  209.     Regs.r_di = FP_OFF (&pr);
  210.  
  211.     Regs.r_ds = FP_SEG (&pc);
  212.     Regs.r_si = FP_OFF (&pc);
  213.  
  214.     intr (33, &Regs);
  215.  
  216.     return (Regs.r_ax);
  217. }
  218.  
  219.  
  220.  
  221. print_name (name)
  222. char *name;
  223. {
  224.     unsigned int RPV;
  225.  
  226.     vr.RL.wh = 0;            
  227.     vr.RL.wl = 130;
  228.  
  229.     vc.SL.wh = 0;
  230.     vc.SL.wl = 102;
  231.  
  232.     vc.FNC = 0x3d;
  233.  
  234.     vc.OT.wh = 0;
  235.     vc.OT.wl = 1;
  236.  
  237.     vc.SN = 1;
  238.  
  239.     vc.ONL = 48;
  240.     vc.PNL = 48;
  241.  
  242.     strcpy (vc.ON, name);
  243.     strcpy (vc.PN, "IDENTIFICATION");
  244.  
  245.     Regs.r_ax = 0xE300;
  246.  
  247.     Regs.r_es = FP_SEG (&vr);
  248.     Regs.r_di = FP_OFF (&vr);
  249.  
  250.     Regs.r_ds = FP_SEG (&vc);
  251.     Regs.r_si = FP_OFF (&vc);
  252.  
  253.     intr (33, &Regs);
  254.     RPV = Regs.r_ax;
  255.  
  256.     if ((RPV & 0x00ff) == 0)
  257.         printf ("  %s", vr.DT);
  258.  
  259. }
  260.  
  261.  
  262.  
  263. prntbyt(value)
  264. BYTE value;
  265. {
  266.     if (value == 0)
  267.         printf ("00");
  268.     else if (value < 0x10)
  269.         printf ("0%X", value);
  270.     else
  271.         printf ("%X", value);
  272. }
  273.  
  274.  
  275.  
  276. tell_all (name)
  277. char *name;
  278. {
  279.     unsigned int RPV;
  280.     int infirst = 1;
  281.  
  282.     printf ("\nBelongs to groups:");
  283.     
  284.     do
  285.     {
  286.         vr.RL.wh = 0;            
  287.         vr.RL.wl = 130;
  288.  
  289.         vc.SL.wh = 0;
  290.         vc.SL.wl = 102;
  291.  
  292.         vc.FNC = 0x3d;
  293.  
  294.         vc.OT.wh = 0;
  295.         vc.OT.wl = 1;
  296.  
  297.         if (infirst)
  298.         {
  299.             vc.SN = 1;
  300.             infirst = 0;
  301.         }
  302.         else
  303.             vc.SN = vc.SN + 1;
  304.  
  305.         vc.ONL = 48;
  306.         vc.PNL = 48;
  307.  
  308.         strcpy (vc.ON, name);
  309.         strcpy (vc.PN, "GROUPS_I'M_IN");
  310.  
  311.         Regs.r_ax = 0xE300;
  312.  
  313.         Regs.r_es = FP_SEG (&vr);
  314.         Regs.r_di = FP_OFF (&vr);
  315.  
  316.         Regs.r_ds = FP_SEG (&vc);
  317.         Regs.r_si = FP_OFF (&vc);
  318.  
  319.         intr (33, &Regs);
  320.         RPV = Regs.r_ax;
  321.  
  322.         if ((RPV & 0x00ff) == 0)
  323.             get_name(vr.DT);
  324.  
  325.     } while ((vr.MR == 0xff) && ((RPV & 0x00ff) == 0));
  326. }
  327.  
  328.  
  329. get_name(ids)
  330. char *ids;
  331. {
  332.     unsigned int GON;
  333.     int i = 0, j, k = 0;
  334.  
  335.     printf ("\n");
  336.  
  337.     do
  338.     {
  339.         gnr.RL.wh = 0;
  340.         gnr.RL.wl = 54;
  341.  
  342.         gnc.SL.wh = 0;
  343.         gnc.SL.wl = 5;
  344.  
  345.         gnc.FNC = 0x36;
  346.  
  347.         gnc.UOID.ah = ids[i++];
  348.         gnc.UOID.al = ids[i++];
  349.         gnc.UOID.bh = ids[i++];
  350.         gnc.UOID.bl = ids[i++];
  351.  
  352.         Regs.r_ax = 0xE300;
  353.  
  354.         Regs.r_es = FP_SEG (&gnr);
  355.         Regs.r_di = FP_OFF (&gnr);
  356.  
  357.         Regs.r_ds = FP_SEG (&gnc);
  358.         Regs.r_si = FP_OFF (&gnc);
  359.  
  360.         intr (33, &Regs);
  361.         GON = Regs.r_ax;
  362.  
  363.         if ((GON & 0x00ff) == 0)
  364.         {
  365.             printf ("  %s", gnr.ON);
  366.             for (j=(12-strlen(gnr.ON));j>0;--j)
  367.                 printf (" ");
  368.             if (k == 3)
  369.             {
  370.                 printf ("\n");
  371.                 k = 0;
  372.             }
  373.             else
  374.                 ++k;
  375.         }
  376.     } while (i < 128);
  377. }
  378.  
  379.  
  380. void New_Netware ()
  381. {
  382.     Regs.r_ax = 0xE300;
  383.  
  384.     cc.SL.wh = 0x00;                /* request packet length    */
  385.     cc.SL.wl = 0x01;
  386.  
  387.     cr.RL.wh = 0x00;        /* reply packet length        */
  388.     cr.RL.wl = 0xff;
  389.  
  390.     cc.FNC = 0x46;
  391.  
  392.     cr.AL = 0x00;
  393.     cr.MOID.al = 0x00;
  394.     cr.MOID.ah = 0x00;
  395.     cr.MOID.bl = 0x00;
  396.     cr.MOID.bh = 0x00;
  397.  
  398.     Regs.r_es = FP_SEG (&cr);
  399.     Regs.r_di = FP_OFF (&cr);
  400.  
  401.     Regs.r_ds = FP_SEG (&cc);
  402.     Regs.r_si = FP_OFF (&cc);
  403.  
  404.     intr (33, &Regs);
  405.  
  406.     if ((cr.MOID.al == 0x00) && (cr.MOID.ah == 0x00) && (cr.MOID.bl == 0x00) && (cr.MOID.bh == 0x00))
  407.     {
  408.         printf ("This utility requires Advanced Netware to run.\n");
  409.         exit();
  410.     }
  411.     if (cr.AL != 0x33)
  412.     {
  413.         printf ("You must have supervisor rights to use this program.\n");
  414.         exit();
  415.     }
  416. }
  417.  
  418. void Logged_In ()
  419. {
  420.     Regs.r_ax = 0xE300;
  421.  
  422.     nr.RL.wh = 0x00;        /* set reply buffer to 256 */
  423.     nr.RL.wl = 0xFF;
  424.  
  425.     nc.SL.wh = 0x00;            /* packet request length = 5 */
  426.     nc.SL.wl = 0x05;                /* char = 1  -  longs = 4    */
  427.  
  428.     Regs.r_es = FP_SEG (&nr);
  429.     Regs.r_di = FP_OFF (&nr);
  430.  
  431.     Regs.r_ds = FP_SEG (&nc);
  432.     Regs.r_si = FP_OFF (&nc);
  433.  
  434.     nc.FNC = 0x36;
  435.  
  436.     nc.UOID.ah = cr.MOID.ah;            /* use user id obtained earlier */
  437.     nc.UOID.al = cr.MOID.al;
  438.     nc.UOID.bh = cr.MOID.bh;
  439.     nc.UOID.bl = cr.MOID.bl;
  440.  
  441.     intr (33, &Regs);
  442.  
  443.     if ((Regs.r_ax & 0x00ff) != 0)
  444.     {
  445.         printf ("You must be logged into the network to run this program.\n");
  446.         exit();
  447.     }
  448. }
  449.  
  450.  
  451. main (argc, argv)
  452. int argc;
  453. char *argv[];
  454. {
  455.     New_Netware ();
  456.  
  457.     Logged_In ();
  458.  
  459.     Users (strupr(argv[1]));
  460. }
  461.