home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / rsyssrc.lha / RSysDoslists.c < prev    next >
C/C++ Source or Header  |  1993-09-25  |  9KB  |  463 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysDosLists.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    void MakeAssignList ( void );
  12. *    void MakeVolumeList ( void );
  13. *    void RSysLockList ( void );
  14. *    void SysCLIList ( void );
  15. *    void SysResidentList ( void );
  16. *    void SysResidentProg ( void );
  17. *
  18. *      --- Lokale  Routinen ---
  19. *
  20. *
  21. * Bemerkungen:
  22. *      Erzeugung von Listen der DOS-Library.
  23. *
  24. * Erstellungsdatum:
  25. *      07-Jul-93     Rolf Böhme
  26. *
  27. * Änderungen:
  28. *      07-Jul-93     Rolf Böhme      Erstellung
  29. *
  30. ***************************************************************************
  31. */
  32.  
  33. #include "RSys.h"
  34.  
  35.     /*
  36.      * MakeAssignList() erzeugt eine Liste aller Assigns im
  37.      * System
  38.      */
  39. void
  40. MakeAssignList(void)
  41. {
  42.     int    i = 0;
  43.     char    helpdir[MAXFULLNAME],dir[39];
  44.     struct DosList *dl;
  45.     BPTR    lock;
  46.  
  47.     DPOS;
  48.  
  49.     countentries = CountDevices(LDF_ASSIGNS);
  50.  
  51.     if (NoEntries()) return;
  52.  
  53.     Entries = AllocScrollEntries(countentries);
  54.  
  55.     dl = LockDosList(LDF_ASSIGNS | LDF_READ);
  56.  
  57.     while ((dl = NextDosEntry(dl, LDF_ASSIGNS | LDF_READ)) && (i < countentries))
  58.     {
  59.         B2CStr(Entries[i].se_obj_id.fullname, dl->dol_Name);
  60.         strcat(Entries[i].se_obj_id.fullname, ":");
  61.  
  62.         if (lock = Lock((UBYTE *) Entries[i].se_obj_id.fullname, ACCESS_READ))
  63.         {
  64.             NameFromLock(lock, (UBYTE *) helpdir, 107);
  65.             strncpy(dir, helpdir, 38);
  66.  
  67.             UnLock(lock);
  68.         }
  69.         else strcpy(dir, field[NO_LOCK]);
  70.  
  71.         sprintf(Entries[i].se_Entry, EntryAttr[ASSIGNS].ea_dataformat,
  72.                   Entries[i].se_obj_id.fullname, dir);
  73.  
  74.         AddNodeToList(i, SORT, 0);
  75.  
  76.         i++;
  77.     }
  78.  
  79.     UnLockDosList(LDF_ASSIGNS | LDF_READ);
  80.  
  81.     PrintStatistics();
  82.  
  83.     return;
  84. }
  85.  
  86.     /*
  87.      * MakeVolumeList() erzeugt eine Liste aller Volumes im
  88.      * System
  89.      */
  90. void
  91. MakeVolumeList(void)
  92. {
  93.     int    i = 0;
  94.     struct DosList *dl;
  95.     long free, used, percentused;
  96.     char state[6],type[6];
  97.  
  98.     DPOS;
  99.  
  100.     DisableSysRequest(TRUE);
  101.  
  102.     countentries = CountDevices(LDF_VOLUMES);
  103.  
  104.     if (NoEntries()) return;
  105.  
  106.     Entries = AllocScrollEntries(countentries);
  107.  
  108.     dl = LockDosList(LDF_VOLUMES | LDF_READ);
  109.  
  110.     while ((dl = NextDosEntry(dl, LDF_VOLUMES | LDF_READ)) && (i < countentries))
  111.     {
  112.         B2CStr(Entries[i].se_obj_id.fullname, dl->dol_Name);
  113.         strcat(Entries[i].se_obj_id.fullname, ":");
  114.  
  115.         FreeBytes(Entries[i].se_obj_id.fullname,&free,&used,&percentused, state,type);
  116.  
  117.         sprintf(Entries[i].se_Entry, EntryAttr[VOLUMES].ea_dataformat,
  118.                   Entries[i].se_obj_id.fullname,
  119.                   free, used, percentused,
  120.                   (percentused > 90L) ? '*' : ' ',
  121.                   state, type);
  122.  
  123.         AddNodeToList(i, SORT, 0);
  124.  
  125.         i++;
  126.     }
  127.  
  128.     UnLockDosList(LDF_VOLUMES | LDF_READ);
  129.  
  130.     DisableSysRequest(FALSE);
  131.  
  132.     PrintStatistics();
  133.  
  134.     return;
  135. }
  136.  
  137. void
  138. RSysLockList(void)
  139. {
  140.     struct List *DispList;
  141.     struct Remember *DispKey = NULL;
  142.     struct Node *node;
  143.    struct lockentry {
  144.       struct Node node;
  145.       struct objectid obj;
  146.    } *LockNode;
  147.     BPTR    lo;
  148.     struct DosList *dl;
  149.     register struct FileLock *lptr,
  150.                                      *alptr = NULL;
  151.     char buffer[MAXFULLNAME], *access[] = { "-----", "WRITE", "READ" };
  152.     int i;
  153.  
  154.    HandleHelp(MN_RSysLockList);
  155.  
  156.     PrintHeader(VOLLOCKS, NULL);
  157.  
  158.     EmptyListView();
  159.  
  160.     DispList = AllocRemember(&DispKey,sizeof(struct List),MEMF_CLEAR);
  161.     if(DispList)
  162.     {
  163.         NewList(DispList);
  164.  
  165.         Forbid();
  166.  
  167.         dl = LockDosList(LDF_VOLUMES | LDF_READ);
  168.  
  169.         while (dl)
  170.         {
  171.             if ((dl->dol_Type == DLT_VOLUME) && B2CStr(buffer, dl->dol_Name))
  172.             {
  173.                 strcat(buffer, ":");
  174.  
  175.                 if (lo = Lock((UBYTE *)buffer, ACCESS_READ))
  176.                 {
  177.                     for (lptr = BPTR_TO_C(FileLock, lo);lptr != NULL; lptr = BPTR_TO_C(FileLock, lptr->fl_Link))
  178.                     {
  179.                         if (NameFromLock(C_TO_BPTR(lptr), (UBYTE *)buffer, MAXFULLNAME-1) &&
  180.                              (LockNode = AllocRemember(&DispKey,sizeof(struct lockentry), MEMF_CLEAR)) &&
  181.                              (LockNode->node.ln_Name = AllocRemember(&DispKey,BUFSIZE, MEMF_CLEAR)))
  182.                         {
  183.                             sprintf(LockNode->node.ln_Name,EntryAttr[VOLLOCKS].ea_dataformat,
  184.                              (APTR)C_TO_BPTR(lptr),
  185.                                       buffer, access[-lptr->fl_Access]);
  186.  
  187.                      strncpy(LockNode->obj.fullname, buffer, MAXFULLNAME);
  188.                      LockNode->obj.address = (APTR)C_TO_BPTR(lptr);
  189.  
  190.                             AddNodeSorted(DispList,&(LockNode->node), 9);
  191.                         }
  192.  
  193.                         if (BPTR_TO_C(FileLock, lptr->fl_Link) == alptr) break;
  194.  
  195.                         alptr = lptr;
  196.                     }
  197.  
  198.                     UnLock(lo);
  199.                 }
  200.             }
  201.  
  202.             dl = NextDosEntry(dl, LDF_VOLUMES | LDF_READ);
  203.         }
  204.  
  205.         UnLockDosList(LDF_VOLUMES | LDF_READ);
  206.  
  207.         Permit();
  208.  
  209.         countentries = CountNodes(DispList);
  210.  
  211.         if(!NoEntries())
  212.         {
  213.             Entries = AllocScrollEntries(countentries);
  214.  
  215.             for(node = DispList->lh_Head, i = 0; node->ln_Succ && (i < countentries);
  216.                  node = node->ln_Succ, i++)
  217.          {
  218.                 strcpy(Entries[i].se_Entry, node->ln_Name);
  219.             Entries[i].se_obj_id.address = ((struct lockentry *)node)->obj.address;
  220.             strcpy(Entries[i].se_obj_id.fullname, ((struct lockentry *)node)->obj.fullname);
  221.          }
  222.  
  223.             CreateEntryList(SORT, 9);
  224.         }
  225.  
  226.         FreeRemember(&DispKey,TRUE);
  227.  
  228.         PrintStatistics();
  229.     }
  230.     else ErrorHandle("Tmp LockList", MEMORY_ERR, ALLOC_FAIL, KILL);
  231.  
  232.     return;
  233. }
  234.  
  235.     /*
  236.      * SysResidentList() listet die residenten Handler
  237.      * aller Devices auf
  238.      */
  239. void
  240. SysResidentList(void)
  241. {
  242.     int    i = 0;
  243.     struct FileSysStartupMsg *fssm;
  244.     struct DosList *dl;
  245.     char devhandler[30];
  246.  
  247.     DPOS;
  248.  
  249.    HandleHelp(MN_SysResidentList);
  250.  
  251.     PrintHeader(DEVS, NULL);
  252.  
  253.     EmptyListView();
  254.  
  255.     countentries = CountDevices(CNTMASK);
  256.  
  257.     if (NoEntries()) return;
  258.  
  259.     Entries = AllocScrollEntries(countentries);
  260.  
  261.     DisableSysRequest(TRUE);
  262.  
  263.     dl = LockDosList(MASK);
  264.  
  265.     while ((dl = NextDosEntry(dl, MASK)) && (i < countentries))
  266.     {
  267.         B2CStr(Entries[i].se_obj_id.fullname, dl->dol_Name);
  268.         strcat(Entries[i].se_obj_id.fullname, ":");
  269.  
  270.       Entries[i].se_obj_id.address = dl;
  271.  
  272.         if (dl->dol_Task && (fssm = B2C(dl->dol_misc.dol_handler.dol_Startup)))
  273.             B2CStr(devhandler, fssm->fssm_Device);
  274.         else if (dl->dol_misc.dol_handler.dol_Handler)
  275.             B2CStr(devhandler, dl->dol_misc.dol_handler.dol_Handler);
  276.         else
  277.             strcpy(devhandler, field[NO_HANDLER]);
  278.  
  279.         sprintf(Entries[i].se_Entry, EntryAttr[DEVS].ea_dataformat,
  280.                   Entries[i].se_obj_id.fullname, devhandler);
  281.  
  282.         i++;
  283.     }
  284.  
  285.     countentries = i;
  286.  
  287.     UnLockDosList(MASK);
  288.  
  289.     DisableSysRequest(FALSE);
  290.  
  291.     CreateEntryList(SORT, 0);
  292.  
  293.     PrintStatistics();
  294.  
  295.     return;
  296. }
  297.  
  298.     /*
  299.      * SysCLIList() erzeugt eine Liste aller CLI's im System
  300.      */
  301. void
  302. SysCLIList(void)
  303. {
  304.     int    clicnt,
  305.             i = 0;
  306.     struct Process *cliproc;
  307.  
  308.    HandleHelp(MN_SysCLIList);
  309.  
  310.     DPOS;
  311.  
  312.     PrintHeader(CLI, NULL);
  313.  
  314.     EmptyListView();
  315.  
  316.     countentries = MaxCli();
  317.  
  318.     if (NoEntries()) return;
  319.  
  320.     Entries = AllocScrollEntries(countentries);
  321.  
  322.     Forbid();
  323.  
  324.     for (clicnt = 1; clicnt < countentries; clicnt++)
  325.     {
  326.         cliproc = FindCliProc((ULONG) clicnt);
  327.         if (cliproc)
  328.         {
  329.             savestrcpy(Entries[i].se_obj_id.fullname, &(cliproc->pr_Task.tc_Node),
  330.                           MAXFULLNAME - 1, NT_PROCESS);
  331.          Entries[i].se_obj_id.address = cliproc;
  332.  
  333.             sprintf(Entries[i].se_Entry, EntryAttr[CLI].ea_dataformat,
  334.                  Entries[i].se_obj_id.address,
  335.                       (char)cliproc->pr_TaskNum,
  336.                       Entries[i].se_obj_id.fullname,
  337.                       cliproc->pr_Task.tc_Node.ln_Pri,
  338.                       ((ULONG) cliproc->pr_Task.tc_SPUpper -
  339.                         (ULONG) cliproc->pr_Task.tc_SPLower));
  340.  
  341.             i++;
  342.         }
  343.     }
  344.  
  345.     countentries = i;
  346.  
  347.     Permit();
  348.  
  349.     CreateEntryList(SORT, 9);
  350.  
  351.     PrintStatistics();
  352.  
  353.     return;
  354. }
  355.  
  356. void
  357. SysResidentProg(void)
  358. {
  359.    struct ResidentList
  360.    {
  361.        BPTR    rl_Next;
  362.        LONG    rl_UseCount;
  363.        BPTR    rl_SegList;
  364.        BSTR    rl_SegName;
  365.    };
  366.     char    name[BUFSIZE];
  367.    struct RootNode *RN = DOSBase->dl_Root;
  368.    struct DosInfo *di = (struct DosInfo *) BADDR(RN->rn_Info);
  369.    struct ResidentList *RL = (struct ResidentList *) BADDR(di->di_NetHand),
  370.         *loop = RL;
  371.     int    cnt = 0, i;
  372.  
  373.     DPOS;
  374.  
  375.    HandleHelp(MN_SysResidentProg);
  376.  
  377.     PrintHeader(RESIDENTS, NULL);
  378.  
  379.     EmptyListView();
  380.  
  381.     PrintInfo("Counting residents", NO_SPEAK, 0);
  382.  
  383.     Forbid();
  384.  
  385.     for (loop = RL; loop; loop = (struct ResidentList *) BADDR(loop->rl_Next))
  386.         cnt++;
  387.  
  388.     Permit();
  389.  
  390.     countentries = cnt;
  391.  
  392.     if (NoEntries()) return;
  393.  
  394.     Entries = AllocScrollEntries(countentries);
  395.  
  396.     Forbid();
  397.  
  398.     cnt = 0;
  399.  
  400.     for (loop = RL; loop && (cnt < countentries); loop = (struct ResidentList *) BADDR(loop->rl_Next))
  401.     {
  402.         for (i = 0; (i < *(UBYTE *)&loop->rl_SegName) && (i < BUFSIZE); i++)
  403.             name[i] = (char)*(UBYTE *) (((BPTR)&loop->rl_SegName) + i + 1L);
  404.  
  405.         name[i] = STRINGEND;
  406.  
  407.       Entries[cnt].se_obj_id.address = loop;
  408.  
  409.         sprintf(Entries[cnt].se_Entry, EntryAttr[RESIDENTS].ea_dataformat,
  410.               Entries[cnt].se_obj_id.address,
  411.                   name,
  412.                   loop->rl_UseCount,
  413.                   ((loop->rl_UseCount >= 0) ? "EXTERNAL" :
  414.                            ((loop->rl_UseCount == -1) ? "SYSTEM" : "INTERNAL")));
  415.  
  416.         cnt++;
  417.     }
  418.  
  419.     countentries = cnt;
  420.  
  421.     Permit();
  422.  
  423.     CreateEntryList(SORT, 9);
  424.  
  425.     PrintStatistics();
  426.  
  427.     return;
  428. }
  429.  
  430. void
  431. RSysFaultMessages(void)
  432. {
  433.    int cnt;
  434.    UBYTE fmsg[BUFSIZE];
  435.  
  436. /*   HandleHelp(MN_SysResidentProg);*/
  437.  
  438.     PrintHeader(FAULTMSG, NULL);
  439.  
  440.     EmptyListView();
  441.  
  442.    countentries = 256;
  443.  
  444.     Entries = AllocScrollEntries(countentries);
  445.  
  446.     sprintf(Entries[0].se_Entry, EntryAttr[FAULTMSG].ea_dataformat,
  447.            0, field[NO_FIELD]);
  448.  
  449.    for(cnt = 1; cnt < countentries; cnt++)
  450.    {
  451.       Fault(cnt, (UBYTE *)"-", fmsg, BUFSIZE-1);
  452.  
  453.           sprintf(Entries[cnt].se_Entry, EntryAttr[FAULTMSG].ea_dataformat,
  454.               cnt, &fmsg[2]);
  455.    }
  456.  
  457.     CreateEntryList(NO_SORT, 0);
  458.  
  459.     PrintStatistics();
  460.  
  461.    return;
  462. }
  463.