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