workbench/libs/rexxsupport/showlist.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Rexx stub for AllocMem system function
   6     Lang: English
   7 */
   8
   9 #include <proto/exec.h>
  10 #include <proto/dos.h>
  11 #include <proto/rexxsyslib.h>
  12 #include <exec/types.h>
  13 #include <exec/memory.h>
  14 #include <dos/dos.h>
  15 #include <dos/dosextens.h>
  16 #include <rexx/storage.h>
  17 #include <rexx/errors.h>
  18
  19 #include <ctype.h>
  20 #include <string.h>
  21
  22 #include "rexxsupport_intern.h"
  23 #include "rxfunctions.h"
  24
  25 #ifndef AROS_BSTR_ADDR
  26 #   define AROS_BSTR_ADDR(s) (((STRPTR)BADDR(s))+1)
  27 #endif
  28
  29 #if defined(__AROSPLATFORM_SMP__)
  30 #include <aros/types/spinlock_s.h>
  31 #include <proto/execlock.h>
  32 #include <resources/execlock.h>
  33 #endif
  34
  35 LONG rxsupp_showlist(struct Library *RexxSupportBase, struct RexxMsg *msg, UBYTE **argstring)
  36 {
  37     UBYTE argc = msg->rm_Action & RXARGMASK;
  38     BOOL isexec;
  39     char delim = 0;
  40     struct List *execl = NULL;
  41     ULONG dosflags = 0L;
  42     UBYTE *string, *name = NULL;
  43     ULONG ssize;
  44
  45 #if defined(__AROSPLATFORM_SMP__)
  46         void *ExecLockBase = OpenResource("execlock.resource");
  47 #endif
  48
  49     if (RXARG(msg, 1) == NULL || LengthArgstring(RXARG(msg, 1)) == 0)
  50     {
  51         *argstring = NULL;
  52         return ERR10_018;
  53     }
  54     switch (tolower(RXARG(msg, 1)[0]))
  55     {
  56     case 'a':
  57         isexec = FALSE;
  58         dosflags = LDF_READ | LDF_ASSIGNS;
  59         break;
  60
  61     case 'd':
  62         isexec = TRUE;
  63         execl = &SysBase->DeviceList;
  64         break;
  65
  66     case 'h':
  67         isexec = FALSE;
  68         dosflags = LDF_READ | LDF_DEVICES;
  69         break;
  70
  71     case 'i':
  72         isexec = TRUE;
  73         execl = &SysBase->IntrList;
  74         break;
  75
  76     case 'l':
  77         isexec = TRUE;
  78         execl = &SysBase->LibList;
  79         break;
  80
  81     case 'm':
  82         isexec = TRUE;
  83         execl= &SysBase->MemList;
  84         break;
  85
  86     case 'p':
  87         isexec = TRUE;
  88         execl = &SysBase->PortList;
  89         break;
  90
  91     case 'r':
  92         isexec = TRUE;
  93         execl = &SysBase->ResourceList;
  94         break;
  95
  96     case 's':
  97         isexec = TRUE;
  98         execl = &SysBase->SemaphoreList;
  99         break;
 100
 101     case 't':
 102         isexec = TRUE;
 103         execl = &SysBase->TaskReady;
 104         break;
 105
 106     case 'v':
 107         isexec = FALSE;
 108         dosflags = LDF_READ | LDF_VOLUMES;
 109         break;
 110
 111     case 'w':
 112         isexec = TRUE;
 113         execl = &SysBase->TaskWait;
 114         break;
 115
 116     default:
 117         *argstring = NULL;
 118         return ERR10_018;
 119     }
 120
 121     if (argc < 2 || RXARG(msg, 2) == NULL)
 122         name = NULL;
 123     else
 124         name = RXARG(msg, 2);
 125
 126     if (argc < 3 || RXARG(msg, 3) ==  NULL || LengthArgstring(RXARG(msg, 3)) == 0)
 127         delim = ' ';
 128     else
 129         delim = RXARG(msg, 3)[0];
 130
 131     if (name == NULL)
 132     {
 133         ssize = 1024;
 134         string = AllocMem(ssize, MEMF_ANY);
 135         string[0] = 0;
 136         if (isexec)
 137         {
 138             struct Node *n;
 139             ULONG slen, totlen;
 140
 141 #if defined(__AROSPLATFORM_SMP__)
 142                 if (ExecLockBase)
 143                         ObtainSystemLock(execl, SPINLOCK_MODE_READ, LOCKF_DISABLE);
 144                 else
 145                         Disable();
 146 #else
 147             Disable();
 148 #endif
 149             ForeachNode(execl, n)
 150             {
 151                 slen = strlen(string);
 152                 totlen = slen + strlen(n->ln_Name) + 2;
 153                 if (totlen > ssize)
 154                 {
 155                     ULONG oldsize = ssize;
 156                     UBYTE *oldstring = string;
 157
 158                     ssize = ((totlen/1024)+1)*1024;
 159                     string = AllocMem(ssize, MEMF_ANY);
 160                     strcpy(string, oldstring);
 161                     FreeMem(oldstring, oldsize);
 162                 }
 163                 if (slen > 0)
 164                 {
 165                     string[slen] = delim;
 166                     string[slen+1] = 0;
 167                 }
 168                 strcat(string, n->ln_Name);
 169             }
 170 #if defined(__AROSPLATFORM_SMP__)
 171                 if (ExecLockBase)
 172                         ReleaseSystemLock(execl, LOCKF_DISABLE);
 173                 else
 174                         Enable();
 175 #else
 176             Enable();
 177 #endif
 178         }
 179         else
 180         {
 181             struct DosList *dosl = LockDosList(dosflags);
 182             UBYTE *name;
 183             ULONG slen, totlen;
 184
 185             while ((dosl = NextDosEntry(dosl, dosflags)) != NULL)
 186             {
 187                 name = (STRPTR)AROS_BSTR_ADDR(dosl->dol_Name);
 188                 slen = strlen(string);
 189                 totlen = slen + strlen(name) + 2;
 190                 if (totlen > ssize)
 191                 {
 192                     ULONG oldsize = ssize;
 193                     UBYTE *oldstring = string;
 194
 195                     ssize = ((totlen/1024)+1)*1024;
 196                     string = AllocMem(ssize, MEMF_ANY);
 197                     strcpy(string, oldstring);
 198                     FreeMem(oldstring, oldsize);
 199                 }
 200                 if (slen > 0)
 201                 {
 202                     string[slen] = delim;
 203                     string[slen+1] = 0;
 204                 }
 205                 strncat(string, name, *(UBYTE *)dosl->dol_Name);
 206             }
 207             UnLockDosList(dosflags);
 208         }
 209         *argstring = CreateArgstring(string, strlen(string));
 210         FreeMem(string, ssize);
 211     }
 212     else /* name != NULL */
 213     {
 214         BOOL found = FALSE;
 215
 216         if (isexec)
 217         {
 218             struct Node *n;
 219
 220 #if defined(__AROSPLATFORM_SMP__)
 221                 if (ExecLockBase)
 222                         ObtainSystemLock(execl, SPINLOCK_MODE_READ, LOCKF_DISABLE);
 223                 else
 224                         Disable();
 225 #else
 226             Disable();
 227 #endif
 228             ForeachNode(execl, n)
 229             {
 230                 found = strcmp(name, n->ln_Name)==0;
 231                 if (found)
 232                     break;
 233             }
 234 #if defined(__AROSPLATFORM_SMP__)
 235                 if (ExecLockBase)
 236                         ReleaseSystemLock(execl, LOCKF_DISABLE);
 237                 else
 238                         Enable();
 239 #else
 240             Enable();
 241 #endif
 242         }
 243         else
 244         {
 245             struct DosList *dosl = LockDosList(dosflags);
 246
 247             while(!found && (dosl = NextDosEntry(dosl, dosflags))!=NULL)
 248                 found = strncmp(name, (STRPTR)BADDR(dosl->dol_Name)+1, *(UBYTE *)dosl->dol_Name)==0;
 249
 250             UnLockDosList(dosflags);
 251         }
 252         if (found)
 253             *argstring = CreateArgstring("1",1);
 254         else
 255             *argstring = CreateArgstring("0",1);
 256     }
 257
 258     return RC_OK;
 259 }