workbench/c/shellcommands/Resident.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Resident CLI command
   6     Lang: English
   7 */
   8
   9
  10 #include <proto/dos.h>
  11 #include <dos/dosextens.h>
  12 #include <string.h>
  13 #include <exec/lists.h>
  14 #include <exec/nodes.h>
  15 #include <exec/memory.h>
  16
  17 #include <string.h>
  18
  19 #include <aros/shcommands.h>
  20
  21 struct SegNode
  22 {
  23     struct MinNode node;
  24     IPTR data[2];
  25 };
  26
  27 static struct SegNode *NewSegNode(struct ExecBase *SysBase, STRPTR name, LONG uc);
  28
  29 AROS_SH7(Resident, 41.1,
  30 AROS_SHA(STRPTR, ,NAME, ,NULL),
  31 AROS_SHA(STRPTR, ,FILE, ,NULL),
  32 AROS_SHA(BOOL, ,REMOVE,/S,FALSE),
  33 AROS_SHA(BOOL, ,ADD,/S,FALSE),
  34 AROS_SHA(BOOL, ,REPLACE,/S,FALSE),
  35 AROS_SHA(BOOL,PURE=,FORCE,/S,FALSE),
  36 AROS_SHA(BOOL, ,SYSTEM,/S,FALSE))
  37 {
  38     AROS_SHCOMMAND_INIT
  39
  40
  41     if (SHArg(FILE) || SHArg(NAME))
  42     {
  43         STRPTR name, file;
  44         BPTR seglist;
  45         struct FileInfoBlock *fib;
  46
  47         if (SHArg(FILE))
  48         {
  49             name = SHArg(NAME);
  50             file = SHArg(FILE);
  51         }
  52         else
  53         {
  54             name = FilePart(SHArg(NAME));
  55             file = SHArg(NAME);
  56         }
  57
  58         SetIoErr(0);
  59         if (SHArg(REMOVE))
  60         {
  61             struct Segment *found;
  62
  63             Forbid();
  64             found = FindSegment(name, NULL, TRUE);
  65             if (!found)
  66             {
  67                 Permit();
  68                 SetIoErr(ERROR_OBJECT_NOT_FOUND);
  69             }
  70             else
  71             if (!RemSegment(found))
  72             {
  73                 if (found->seg_UC == CMD_INTERNAL)
  74                     found->seg_UC = CMD_DISABLED;
  75                 else
  76                     SetIoErr(ERROR_OBJECT_IN_USE);
  77             }
  78
  79             if (IoErr())
  80             {
  81                 PrintFault(IoErr(), SHArg(NAME));
  82                 return RETURN_FAIL;
  83             }
  84
  85             return RETURN_OK;
  86         }
  87
  88         if (SHArg(REPLACE))
  89         {
  90             struct Segment *found;
  91
  92             Forbid();
  93             found = FindSegment(name, NULL, TRUE);
  94             if (found && found->seg_UC == CMD_DISABLED)
  95             {
  96                 found->seg_UC = CMD_INTERNAL;
  97                 Permit();
  98                 return RETURN_OK;
  99             }
 100             Permit();
 101         }
 102
 103         if (!SHArg(ADD)) SHArg(REPLACE) = TRUE;
 104
 105         if (!SHArg(FORCE) && (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)))
 106         {
 107             BPTR lock;
 108
 109             if ((lock = Lock(file, SHARED_LOCK)))
 110             {
 111                  if (Examine(lock, fib))
 112                  {
 113                      if (fib->fib_Protection & FIBF_PURE)
 114                          SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 115                  }
 116
 117                  UnLock(lock);
 118             }
 119
 120             FreeDosObject(DOS_FIB, fib);
 121         }
 122
 123         if (IoErr() || !(seglist = LoadSeg(file)))
 124         {
 125             PrintFault(IoErr(), file);
 126             return RETURN_FAIL;
 127         }
 128
 129         if (SHArg(REPLACE))
 130         {
 131             struct Segment *found;
 132
 133             Forbid();
 134             found = FindSegment(name, NULL, FALSE);
 135
 136             if (found)
 137             {
 138                 if (found->seg_UC != 0)
 139                 {
 140                      Permit();
 141                      PrintFault(ERROR_OBJECT_IN_USE, file);
 142                      UnLoadSeg(seglist);
 143                      return RETURN_FAIL;
 144                 }
 145
 146                 UnLoadSeg(found->seg_Seg);
 147                 found->seg_Seg = seglist;
 148                 Permit();
 149
 150                 return RETURN_OK;
 151             }
 152         /* Fall through */
 153         }
 154
 155         if (!AddSegment(name, seglist, SHArg(SYSTEM)?CMD_SYSTEM:0))
 156         {
 157             UnLoadSeg(seglist);
 158             PrintFault(IoErr(), "Resident");
 159             return RETURN_FAIL;
 160         }
 161     }
 162     else
 163     {
 164
 165         struct MinList l;
 166         struct Segment *curr;
 167         struct SegNode *n;
 168
 169         NEWLIST((struct List *)&l);
 170
 171         SetIoErr(0);
 172         Forbid();
 173         curr = (struct Segment *)BADDR(DOSBase->dl_ResList);
 174         while (curr)
 175         {
 176             n = NewSegNode(SysBase, AROS_BSTR_ADDR(curr->seg_Name), curr->seg_UC);
 177
 178             if (!n)
 179             {
 180                 SetIoErr(ERROR_NO_FREE_STORE);
 181                 break;
 182             }
 183
 184             AddTail((struct List *)&l, (struct Node *)n);
 185             curr = (struct Segment *)BADDR(curr->seg_Next);
 186         }
 187         Permit();
 188
 189         if (IoErr())
 190         {
 191             PrintFault(IoErr(), "Resident");
 192             return RETURN_FAIL;
 193         }
 194
 195         PutStr("NAME                           USECOUNT\n\n");
 196         while ((n = (struct SegNode *)RemHead((struct List *)&l)))
 197         {
 198             if (n->data[1] == CMD_SYSTEM)
 199                 VPrintf("%-30s SYSTEM\n", n->data);
 200             else
 201             if (n->data[1] == CMD_INTERNAL)
 202                 VPrintf("%-30s INTERNAL\n", n->data);
 203             else
 204             if (n->data[1] == CMD_DISABLED)
 205                 VPrintf("%-30s DISABLED\n", n->data);
 206             else
 207                 VPrintf("%-30s %-ld\n", n->data);
 208
 209             FreeVec((APTR)n->data[0]);
 210             FreeVec(n);
 211         }
 212     }
 213
 214
 215     return RETURN_OK;
 216
 217     AROS_SHCOMMAND_EXIT
 218 }
 219
 220 static STRPTR StrDup(struct ExecBase *SysBase, STRPTR str)
 221 {
 222     size_t len = strlen(str)+1;
 223     STRPTR ret = (STRPTR) AllocVec(len, MEMF_ANY);
 224
 225     if (ret)
 226     {
 227         CopyMem(str, ret, len);
 228     }
 229
 230     return ret;
 231 }
 232
 233
 234 static struct SegNode *NewSegNode(struct ExecBase *SysBase, STRPTR name,
 235                                   LONG uc)
 236 {
 237     struct SegNode *sn = AllocVec(sizeof (struct SegNode), MEMF_ANY);
 238
 239     if (sn)
 240     {
 241         sn->data[0] = (IPTR) StrDup(SysBase, name);
 242         if (sn->data[0])
 243         {
 244             sn->data[1] = uc;
 245             return sn;
 246         }
 247
 248         FreeVec(sn);
 249     }
 250
 251     return NULL;
 252 }