home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 2: PC / frozenfish_august_1995.bin / bbs / d09xx / d0905.lha / MultiUser / C.src / Tasks.c < prev    next >
C/C++ Source or Header  |  1993-08-26  |  6KB  |  242 lines
  1. /************************************************************
  2. * MultiUser - MultiUser Task/File Support System                *
  3. * ---------------------------------------------------------    *
  4. * Get Information about Tasks                                            *
  5. * ---------------------------------------------------------    *
  6. * ⌐ Copyright 1993 by Geert Uytterhoeven                            *
  7. * All Rights Reserved.                                                    *
  8. ************************************************************/
  9.  
  10.  
  11. #include    <exec/memory.h>
  12. #include <exec/execbase.h>
  13. #include <proto/exec.h>
  14. #include <proto/dos.h>
  15. #include <string.h>
  16. #include <libraries/multiuser.h>
  17. #include <proto/multiuser.h>
  18.  
  19. #include "Tasks_rev.h"
  20.  
  21.  
  22. char __VersTag__[] = VERSTAG;
  23.  
  24.  
  25. struct TaskInfo {
  26.     struct Task *Task;
  27.     char Name[32];
  28.     ULONG TaskNum;
  29.     UBYTE Type;
  30.     BYTE Priority;
  31.     UWORD uid;
  32. };
  33.  
  34.  
  35. ULONG CountTasks(struct ExecBase *SysBase);
  36. BOOL FillTaskInfo(struct TaskInfo *tasks, ULONG maxtasks, ULONG *numtasks,
  37.                         UWORD currentuid, BOOL all, struct ExecBase *SysBase,
  38.                         struct muBase *muBase);
  39. BOOL FillIt(struct Task *task, struct TaskInfo *info, UWORD currentuid, BOOL all,
  40.                 struct muBase *muBase);
  41. ULONG DumpTaskInfo(struct TaskInfo *tasks, ULONG numtasks,
  42.                         struct DosLibrary *DOSBase, struct muBase *muBase);
  43.  
  44.  
  45. int __saveds Start(char *arg)
  46. {
  47.     struct ExecBase *SysBase;
  48.     struct DosLibrary *DOSBase;
  49.     struct muBase *muBase = NULL;
  50.     struct RDArgs *args;
  51.     LONG argarray[] = {
  52.         NULL, NULL
  53.     };
  54.     UWORD currentuid;
  55.     struct TaskInfo *tasks;
  56.     ULONG maxtasks, numtasks;
  57.     struct muUserInfo *info;
  58.     LONG error = NULL;
  59.     int rc;
  60.  
  61.     SysBase = *(struct ExecBase **)4;
  62.     
  63.     if ((!(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37))) ||
  64.          (!(muBase = (struct muBase *)OpenLibrary("multiuser.library", 39)))) {
  65.         rc = RETURN_FAIL;
  66.         goto Exit;
  67.     }
  68.  
  69.     args = ReadArgs("USERID,ALL/S", argarray, NULL);
  70.     if (!args)
  71.         error = IoErr();
  72.     else {
  73.         if (!argarray[0])
  74.             currentuid = muGetTaskOwner(NULL)>>16;
  75.         else if (info = muAllocUserInfo()) {
  76.             strncpy(info->UserID, (char *)argarray[0], muUSERIDSIZE);
  77.             if (muGetUserInfo(info, muKeyType_UserID))
  78.                 currentuid = info->uid;
  79.             else {
  80.                 VPrintf("Unknown user '%s'\n", &argarray[0]);
  81.                 goto Fail;
  82.             }
  83.             muFreeUserInfo(info);
  84.         } else {
  85.             error = IoErr();
  86.             goto Fail;
  87.         }
  88.         do {
  89.             maxtasks = CountTasks(SysBase)+5;
  90.             if (tasks = AllocVec(maxtasks*sizeof(struct TaskInfo), MEMF_CLEAR)) {
  91.                 if (FillTaskInfo(tasks, maxtasks, &numtasks, currentuid,
  92.                                       (BOOL)argarray[1], SysBase, muBase)) {
  93.                     error = DumpTaskInfo(tasks, numtasks, DOSBase, muBase);
  94.                     rc = RETURN_OK;
  95.                 } else
  96.                     rc = RETURN_ERROR;
  97.                 FreeVec(tasks);
  98.             } else
  99.                 error = IoErr();
  100.         } while (!error && (rc != RETURN_OK));
  101.     }
  102.     FreeArgs(args);
  103. Fail:
  104.     if (error) {
  105.         PrintFault(error, NULL);
  106.         rc = RETURN_ERROR;
  107.     }
  108.  
  109. Exit:
  110.     CloseLibrary((struct Library *)muBase);
  111.     CloseLibrary((struct Library *)DOSBase);
  112.  
  113.     return(rc);
  114. }    
  115.  
  116.  
  117.     /*
  118.      *        Count the number of tasks in the system
  119.      */
  120.  
  121. ULONG CountTasks(struct ExecBase *SysBase)
  122. {
  123.     ULONG i = 1;
  124.     struct Task *task;
  125.  
  126.     Disable();
  127.     for (task = (struct Task *)SysBase->TaskReady.lh_Head;
  128.           task->tc_Node.ln_Succ; task = (struct Task *)task->tc_Node.ln_Succ)
  129.           i++;
  130.     for (task = (struct Task *)SysBase->TaskWait.lh_Head;
  131.           task->tc_Node.ln_Succ; task = (struct Task *)task->tc_Node.ln_Succ)
  132.           i++;
  133.     Enable();
  134.     return(i);
  135. }
  136.  
  137.  
  138.     /*
  139.      *        Fill in information about the tasks
  140.      */
  141.  
  142. BOOL FillTaskInfo(struct TaskInfo *tasks, ULONG maxtasks, ULONG *numtasks,
  143.                         UWORD currentuid, BOOL all, struct ExecBase *SysBase,
  144.                         struct muBase *muBase)
  145. {
  146.     BOOL rc = TRUE;
  147.     struct Task *task;
  148.  
  149.     *numtasks = 0;
  150.     Disable();
  151.     if (FillIt(SysBase->ThisTask, &tasks[*numtasks], currentuid, all, muBase))
  152.         (*numtasks)++;
  153.     for (task = (struct Task *)SysBase->TaskReady.lh_Head;
  154.           (task->tc_Node.ln_Succ) && (*numtasks < maxtasks);
  155.           task = (struct Task *)task->tc_Node.ln_Succ)
  156.         if (FillIt(task, &tasks[*numtasks], currentuid, all, muBase))
  157.             (*numtasks)++;
  158.     if (task->tc_Node.ln_Succ)
  159.         rc = FALSE;
  160.     else {
  161.         for (task = (struct Task *)SysBase->TaskWait.lh_Head;
  162.               (task->tc_Node.ln_Succ) && (*numtasks < maxtasks);
  163.               task = (struct Task *)task->tc_Node.ln_Succ)
  164.             if (FillIt(task, &tasks[*numtasks], currentuid, all, muBase))
  165.                 (*numtasks)++;
  166.         if (task->tc_Node.ln_Succ)
  167.             rc = FALSE;
  168.     }
  169.     Enable();
  170.     return(rc);
  171. }
  172.  
  173.  
  174. BOOL FillIt(struct Task *task, struct TaskInfo *info, UWORD currentuid, BOOL all,
  175.                 struct muBase *muBase)
  176. {
  177.     UWORD uid;
  178.     struct CommandLineInterface *cli;
  179.     char *name;
  180.     ULONG i;
  181.  
  182.     uid = muGetTaskOwner(task)>>16;
  183.     if (all || (uid == currentuid)) {
  184.         info->Task = task;
  185.         if (((info->Type = task->tc_Node.ln_Type) == NT_PROCESS) &&
  186.              (info->TaskNum = ((struct Process *)task)->pr_TaskNum) &&
  187.              (cli = (struct CommandLineInterface *)BADDR(((struct Process *)task)->pr_CLI)) &&
  188.              (name = BADDR(cli->cli_CommandName)) && name[0]) {
  189.             for (i = 0; (i < name[0]) && (i < 31); i++)
  190.                 info->Name[i] = name[i+1];
  191.             info->Name[i] = '\0';
  192.         } else
  193.             strncpy(info->Name, task->tc_Node.ln_Name, 32);
  194.         info->Priority = task->tc_Node.ln_Pri;
  195.         info->uid = uid;
  196.         return(TRUE);
  197.     } else
  198.         return(FALSE);
  199. }
  200.  
  201.  
  202.     /*
  203.      *        Dump the information
  204.      */
  205.  
  206. ULONG DumpTaskInfo(struct TaskInfo *tasks, ULONG numtasks,
  207.                          struct DosLibrary *DOSBase, struct muBase *muBase)
  208. {
  209.     struct muUserInfo *info;
  210.     ULONG error = NULL;
  211.     ULONG i;
  212.     LONG stream[3];
  213.  
  214.     if (info = muAllocUserInfo()) {
  215.         PutStr("Type    Node     Pri Name/Command                     Owner\n");
  216.         PutStr("-----------------------------------------------------------\n");
  217.          for (i= 0; (i < numtasks) && !CheckSignal(SIGBREAKF_CTRL_C); i++) {
  218.              if (tasks[i].Type == NT_PROCESS)
  219.                  if (stream[0] = tasks[i].TaskNum)
  220.                      VPrintf("CLI %3ld ", stream);
  221.                  else
  222.                      PutStr("Process ");
  223.             else
  224.                 PutStr("Task    ");
  225.              stream[0] = (LONG)tasks[i].Task;
  226.              stream[1] = (LONG)tasks[i].Priority;
  227.              stream[2] = (LONG)tasks[i].Name;
  228.             VPrintf("%08lx %3ld %-32s ", stream);
  229.             if ((info->uid = tasks[i].uid) == muOWNER_NOBODY)
  230.                 PutStr("\n");
  231.             else if (muGetUserInfo(info, muKeyType_uid)) {
  232.                 stream[0] = (LONG)info->UserID;
  233.                 VPrintf("%s\n", stream);
  234.             } else
  235.                 PutStr("<UNKNOWN>\n");
  236.         }
  237.         muFreeUserInfo(info);
  238.     } else
  239.         error = IoErr();
  240.     return(error);
  241. }
  242.