workbench/c/shellcommands/Resident.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Resident CLI command
   6     Lang: English
   7 */
   8
   9 /******************************************************************************
  10
  11
  12     NAME
  13
  14         Resident
  15
  16     SYNOPSIS
  17
  18         NAME,FILE,REMOVE/S,ADD/S,REPLACE/S,PURE=FORCE/S,SYSTEM/S
  19
  20     LOCATION
  21
  22         C:
  23
  24     FUNCTION
  25
  26         Handles list of resident commands. Those commands will be
  27         loaded once and then executed from memory.
  28
  29         Only pure commands can be made resident, i.e. they must
  30         be re-entrant and re-executable. Such commands have the "P"
  31         protection flag set.
  32
  33         If called without arguments it lists the resident commands.
  34
  35     INPUTS
  36
  37         NAME    -- The reference name of the resident command. If no
  38                    name is given the filepart of the file argument
  39                    is used.
  40         FILE    -- The file name of the command. It must be an
  41                    absolute path.
  42         REMOVE  -- Deactivates a resident command.
  43         ADD     -- Adds multiple versions of the same command.
  44         REPLACE -- If a resident command already exists, it will be
  45                    replaced. That's the default option.
  46         FORCE   -- Add commands which don't have the "P" bit set.
  47         SYSTEM  -- Adds a command to the system resident list. Those
  48                    commands can't be removed.
  49
  50     RESULT
  51
  52     NOTES
  53
  54     EXAMPLE
  55
  56         RESIDENT C:COPY
  57
  58     BUGS
  59
  60     SEE ALSO
  61
  62     INTERNALS
  63
  64     HISTORY
  65
  66 ******************************************************************************/
  67
  68 #include <proto/dos.h>
  69 #include <dos/dosextens.h>
  70 #include <string.h>
  71 #include <exec/lists.h>
  72 #include <exec/nodes.h>
  73 #include <exec/memory.h>
  74
  75 #include <string.h>
  76
  77 #include <aros/shcommands.h>
  78
  79 struct SegNode
  80 {
  81     struct MinNode node;
  82     IPTR data[2];
  83 };
  84
  85 static struct SegNode *NewSegNode(struct ExecBase *SysBase, STRPTR name, LONG uc);
  86
  87 AROS_SH7(Resident, 41.2,
  88 AROS_SHA(STRPTR, ,NAME, ,NULL),
  89 AROS_SHA(STRPTR, ,FILE, ,NULL),
  90 AROS_SHA(BOOL, ,REMOVE,/S,FALSE),
  91 AROS_SHA(BOOL, ,ADD,/S,FALSE),
  92 AROS_SHA(BOOL, ,REPLACE,/S,FALSE),
  93 AROS_SHA(BOOL,PURE=,FORCE,/S,FALSE),
  94 AROS_SHA(BOOL, ,SYSTEM,/S,FALSE))
  95 {
  96     AROS_SHCOMMAND_INIT
  97
  98
  99     if (SHArg(FILE) || SHArg(NAME))
 100     {
 101         STRPTR name, file;
 102         BPTR seglist;
 103         struct FileInfoBlock *fib;
 104
 105         if (SHArg(FILE))
 106         {
 107             name = SHArg(NAME);
 108             file = SHArg(FILE);
 109         }
 110         else
 111         {
 112             name = FilePart(SHArg(NAME));
 113             file = SHArg(NAME);
 114         }
 115
 116         SetIoErr(0);
 117         if (SHArg(REMOVE))
 118         {
 119             struct Segment *found;
 120
 121             Forbid();
 122             found = FindSegment(name, NULL, FALSE);
 123             if (!found)
 124                 found = FindSegment(name, NULL, TRUE);
 125             if (!found)
 126             {
 127                 Permit();
 128                 SetIoErr(ERROR_OBJECT_NOT_FOUND);
 129             }
 130             else
 131             if (!RemSegment(found))
 132             {
 133                 if (found->seg_UC == CMD_INTERNAL)
 134                     found->seg_UC = CMD_DISABLED;
 135                 else
 136                     SetIoErr(ERROR_OBJECT_IN_USE);
 137             }
 138
 139             if (IoErr())
 140             {
 141                 PrintFault(IoErr(), SHArg(NAME));
 142                 return RETURN_WARN;
 143             }
 144
 145             return RETURN_OK;
 146         }
 147
 148         if (SHArg(REPLACE))
 149         {
 150             struct Segment *found;
 151
 152             Forbid();
 153             found = FindSegment(name, NULL, TRUE);
 154             if (found && found->seg_UC == CMD_DISABLED)
 155             {
 156                 found->seg_UC = CMD_INTERNAL;
 157                 Permit();
 158                 return RETURN_OK;
 159             }
 160             Permit();
 161         }
 162
 163         if (!SHArg(ADD)) SHArg(REPLACE) = TRUE;
 164
 165         if (!SHArg(FORCE) && (fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL)))
 166         {
 167             BPTR lock;
 168
 169             if ((lock = Lock(file, SHARED_LOCK)))
 170             {
 171                 if (Examine(lock, fib))
 172                 {
 173                     if ((fib->fib_Protection & FIBF_PURE) == 0)
 174                         SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 175                 }
 176
 177                 UnLock(lock);
 178             }
 179
 180             FreeDosObject(DOS_FIB, fib);
 181         }
 182
 183         if (IoErr() || !(seglist = LoadSeg(file)))
 184         {
 185             PrintFault(IoErr(), file);
 186             return RETURN_FAIL;
 187         }
 188
 189         if (SHArg(REPLACE))
 190         {
 191             struct Segment *found;
 192
 193             Forbid();
 194             found = FindSegment(name, NULL, FALSE);
 195
 196             if (found)
 197             {
 198                 if (found->seg_UC != 0)
 199                 {
 200                      Permit();
 201                      PrintFault(ERROR_OBJECT_IN_USE, file);
 202                      UnLoadSeg(seglist);
 203                      return RETURN_FAIL;
 204                 }
 205
 206                 UnLoadSeg(found->seg_Seg);
 207                 found->seg_Seg = seglist;
 208                 Permit();
 209
 210                 return RETURN_OK;
 211             }
 212         /* Fall through */
 213         }
 214
 215         /* WB1.x backwards compatibility hack, do not allow
 216          * override of built-in resident or to add l:shell-seg (CLI) */
 217         if (!stricmp(name, "resident") || !stricmp(name, "cli")) {
 218             SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 219             UnLoadSeg(seglist);
 220             return 1; /* yes, return code = 1 in this special case */
 221         }
 222
 223         if (!AddSegment(name, seglist, SHArg(SYSTEM)?CMD_SYSTEM:0))
 224         {
 225             UnLoadSeg(seglist);
 226             PrintFault(IoErr(), "Resident");
 227             return RETURN_FAIL;
 228         }
 229     }
 230     else
 231     {
 232
 233         struct MinList l;
 234         struct Segment *curr;
 235         struct SegNode *n;
 236         struct DosInfo *dinf = BADDR(DOSBase->dl_Root->rn_Info);
 237         BOOL isbreak = FALSE;
 238
 239         NEWLIST((struct List *)&l);
 240
 241         SetIoErr(0);
 242         Forbid();
 243         curr = (struct Segment *)BADDR(dinf->di_ResList);
 244         while (curr)
 245         {
 246             n = NewSegNode(SysBase, AROS_BSTR_ADDR(MKBADDR(&curr->seg_Name[0])), curr->seg_UC);
 247
 248             if (!n)
 249             {
 250                 SetIoErr(ERROR_NO_FREE_STORE);
 251                 break;
 252             }
 253
 254             AddTail((struct List *)&l, (struct Node *)n);
 255             curr = (struct Segment *)BADDR(curr->seg_Next);
 256         }
 257         Permit();
 258
 259         if (IoErr())
 260         {
 261             PrintFault(IoErr(), "Resident");
 262             return RETURN_FAIL;
 263         }
 264
 265         PutStr("NAME                           USECOUNT\n\n");
 266         while ((n = (struct SegNode *)RemHead((struct List *)&l)))
 267         {
 268             if (SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
 269                 isbreak = TRUE;
 270             if (!isbreak) {
 271                 if (n->data[1] == CMD_SYSTEM)
 272                     Printf("%-30s SYSTEM\n", (CONST_STRPTR)n->data[0]);
 273                 else
 274                 if (n->data[1] == CMD_INTERNAL)
 275                     Printf("%-30s INTERNAL\n", (CONST_STRPTR)n->data[0]);
 276                 else
 277                 if (n->data[1] == CMD_DISABLED)
 278                     Printf("%-30s DISABLED\n", (CONST_STRPTR)n->data[0]);
 279                 else
 280                     Printf("%-30s %-ld\n", (CONST_STRPTR)n->data[0], (ULONG)n->data[1]);
 281             }
 282             FreeVec((APTR)n->data[0]);
 283             FreeVec(n);
 284         }
 285         if (isbreak) {
 286             SetIoErr(ERROR_BREAK);
 287             PrintFault(IoErr(), "Resident");
 288             return RETURN_FAIL;
 289         }
 290     }
 291
 292     return RETURN_OK;
 293
 294     AROS_SHCOMMAND_EXIT
 295 }
 296
 297 static STRPTR myStrDup(struct ExecBase *SysBase, STRPTR str)
 298 {
 299     size_t len = strlen(str)+1;
 300     STRPTR ret = (STRPTR) AllocVec(len, MEMF_ANY);
 301
 302     if (ret)
 303     {
 304         CopyMem(str, ret, len);
 305     }
 306
 307     return ret;
 308 }
 309
 310
 311 static struct SegNode *NewSegNode(struct ExecBase *SysBase, STRPTR name,
 312                                   LONG uc)
 313 {
 314     struct SegNode *sn = AllocVec(sizeof (struct SegNode), MEMF_ANY);
 315
 316     if (sn)
 317     {
 318         sn->data[0] = (IPTR) myStrDup(SysBase, name);
 319         if (sn->data[0])
 320         {
 321             sn->data[1] = uc;
 322             return sn;
 323         }
 324
 325         FreeVec(sn);
 326     }
 327
 328     return NULL;
 329 }