workbench/c/shellcommands/Path.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5 */
   6
   7 /*****************************************************************************
   8
   9     NAME
  10
  11         Path [{<dir>}] [ADD] [SHOW] [RESET] [REMOVE] [QUIET] [HEAD]
  12
  13     SYNOPSIS
  14
  15         PATH/M,ADD/S,SHOW/S,RESET/S,REMOVE/S,QUIET/S,HEAD/S
  16
  17     LOCATION
  18
  19         C:
  20
  21     FUNCTION
  22
  23         Changes the search path for commands. Without arguments it shows the path.
  24
  25     INPUTS
  26
  27         PATH    -- path
  28         ADD     -- adds path
  29         SHOW    -- shows path
  30         RESET   -- removes existing path and replaces it by new path
  31         REMOVE  -- removes the given path
  32         QUIET   -- suppresses dialog when a path is not found
  33         HEAD    -- inserts path at beginning of path list
  34
  35     RESULT
  36
  37     NOTES
  38
  39     EXAMPLE
  40
  41         path dh0:work add
  42
  43     BUGS
  44
  45     SEE ALSO
  46
  47     INTERNALS
  48
  49     HISTORY
  50
  51
  52 ******************************************************************************/
  53
  54 #include <exec/memory.h>
  55 #include <proto/exec.h>
  56
  57 #include <dos/dos.h>
  58 #include <dos/dosextens.h>
  59
  60 #include <proto/dos.h>
  61 #include "dos_commanderrors.h"
  62
  63 #include <aros/shcommands.h>
  64
  65 #include <aros/debug.h>
  66
  67 typedef struct CommandLineInterface* CommandLineInterfacePtr;
  68
  69 typedef struct
  70 {
  71     BPTR next;
  72     BPTR lock;
  73 } PathEntry, *PathEntryPtr;
  74
  75 #define PE(x) ((PathEntry *)(BADDR(x)))
  76
  77 static PathEntryPtr FindPathEntry(CommandLineInterfacePtr cli, STRPTR pathName,
  78     PathEntryPtr* predStorage, APTR DOSBase);
  79
  80 static PathEntryPtr InsertPathEntry(PathEntryPtr predecessor, STRPTR pathName, APTR SysBase, APTR DOSBase);
  81
  82 static BOOL IsDirectory(BPTR lock, APTR DOSBase);
  83
  84 AROS_SH7(Path, 45.4,
  85 AROS_SHA(STRPTR *, ,PATH,/M,NULL),
  86 AROS_SHA(BOOL, ,ADD,/S,NULL),
  87 AROS_SHA(BOOL, ,SHOW,/S,NULL),
  88 AROS_SHA(BOOL, ,RESET,/S,NULL),
  89 AROS_SHA(BOOL, ,REMOVE,/S,NULL),
  90 AROS_SHA(BOOL, ,QUIET,/S,NULL),
  91 AROS_SHA(BOOL, ,HEAD,/S,NULL))
  92 {
  93     AROS_SHCOMMAND_INIT
  94
  95         CommandLineInterfacePtr
  96     cli = Cli();
  97
  98     if(!cli)
  99     {
 100         PrintFault(ERROR_SCRIPT_ONLY, "Path");
 101
 102         return RETURN_ERROR;
 103     }
 104
 105     if (SHArg(RESET))
 106     {
 107             PathEntryPtr
 108         cur = PE(cli->cli_CommandDir);
 109
 110         while (cur)
 111         {
 112                 PathEntryPtr
 113             next = PE(cur->next);
 114
 115             UnLock(cur->lock);
 116
 117             FreeVec(BADDR(cur->next));
 118
 119             cur = next;
 120         }
 121
 122         cli->cli_CommandDir = BNULL;
 123     }
 124
 125         STRPTR*
 126     names = SHArg(PATH);
 127
 128     if (names && *names)
 129     {
 130             int
 131         idx;
 132
 133         if (SHArg(REMOVE) && !SHArg(RESET))
 134         {
 135                 PathEntryPtr
 136             pred = NULL,
 137             entry = NULL;
 138
 139             for (idx = 0; names[idx]; ++idx)
 140             {
 141                 entry = FindPathEntry(cli, names[idx], &pred, DOSBase);
 142
 143 /* free the path entry */
 144                 if (NULL != entry)
 145                 {
 146                     if (NULL != pred)
 147                     {
 148                         pred->next = entry->next;
 149                     }
 150                     else
 151                     {
 152                         cli->cli_CommandDir = entry->next;
 153                     }
 154
 155                     if (BNULL != entry->lock)
 156                     {
 157                         UnLock(entry->lock);
 158                     }
 159
 160                     FreeVec(entry);
 161                 }
 162             }
 163         }
 164         else    /* add */
 165         {
 166                 PathEntryPtr
 167             insertAfter = (PathEntryPtr)&cli->cli_CommandDir;
 168
 169             if (!SHArg(HEAD))
 170             {
 171                 /* Search last entry */
 172                 while (BNULL != insertAfter->next)
 173                 {
 174                     insertAfter = PE(insertAfter->next);
 175                 }
 176             }
 177
 178             for (idx = 0; names[idx]; ++idx)
 179             {
 180                 if (NULL != FindPathEntry(cli, names[idx], NULL, DOSBase))
 181                 {
 182 /* don't add if already in path */
 183                     continue;
 184                 }
 185                 else
 186                 {
 187                     insertAfter = InsertPathEntry(insertAfter, names[idx], SysBase, DOSBase);
 188                 }
 189             }
 190         }
 191     }
 192     else
 193     {
 194         SHArg(SHOW) = SHArg(RESET) == 0;
 195     }
 196
 197     if (SHArg(SHOW))
 198     {
 199         UBYTE Buffer[2048];
 200
 201         PutStr("Current Directory\n");
 202
 203             PathEntryPtr
 204         cur = NULL;
 205
 206         for (cur = PE(cli->cli_CommandDir); cur; cur = PE(cur->next))
 207         {
 208             NameFromLock (cur->lock, Buffer, sizeof (Buffer));
 209
 210             PutStr(Buffer);
 211             PutStr("\n");
 212         }
 213
 214         PutStr("C:\n");
 215     }
 216
 217     return RETURN_OK;
 218
 219     AROS_SHCOMMAND_EXIT
 220 }
 221
 222
 223 /** find the specfied path name in the specified CLI's path list.
 224  *
 225  * @autodoc:function if the path specified by pathName is in the path list of
 226  * the specified CLI the corresponding path entry is returned. the path entry's
 227  * predecessor is stored in the specified location if the storage pointer is
 228  * not NULL.
 229  *
 230  */
 231 static PathEntryPtr
 232 FindPathEntry(CommandLineInterfacePtr cli, STRPTR pathName,
 233     PathEntryPtr* predStorage, APTR DOSBase)
 234 {
 235         PathEntryPtr
 236     entry = NULL;
 237
 238     if (NULL != cli && BNULL != cli->cli_CommandDir && NULL != pathName)
 239     {
 240             BPTR
 241         pathLock = Lock(pathName, ACCESS_READ);
 242
 243         if (BNULL != pathLock)
 244         {
 245                 PathEntryPtr
 246             pred = NULL,
 247             curr = PE(cli->cli_CommandDir);
 248
 249             while (NULL != curr)
 250             {
 251                     LONG
 252                 value = SameLock(pathLock, curr->lock);
 253
 254                 if (LOCK_SAME == value)
 255                 {
 256                     entry = curr;
 257
 258                     if (NULL != predStorage)
 259                     {
 260                         *predStorage = pred;
 261                     }
 262                     break;
 263                 }
 264                 else
 265                 {
 266                     pred = curr;
 267                     curr = PE(curr->next);
 268                 }
 269             }
 270
 271             UnLock(pathLock);
 272         }
 273         else
 274             PrintFault(IoErr(), pathName);
 275     }
 276
 277     return(entry);
 278 }
 279
 280
 281 /* insert a path entry for the specified path
 282  *
 283  * create and insert a path entry for the specified path name. the new path
 284  * entry is inserted after the specified predecessor.
 285  *
 286  * returns the path entry or NULL for failure.
 287  */
 288 static PathEntryPtr
 289 InsertPathEntry(PathEntryPtr predecessor, STRPTR pathName, APTR SysBase, APTR DOSBase)
 290 {
 291         PathEntryPtr
 292     pathEntry = NULL;
 293
 294     {
 295             PathEntryPtr
 296         newEntry = AllocVec(sizeof(PathEntry), MEMF_ANY);
 297
 298             BPTR
 299         lock = Lock(pathName, SHARED_LOCK);
 300
 301             BOOL
 302         isDirectory = (BNULL != lock)
 303             ? IsDirectory(lock, DOSBase)
 304             : FALSE;
 305
 306         if (newEntry != NULL && lock != BNULL && isDirectory)
 307         {
 308             newEntry->lock = lock;
 309             newEntry->next = predecessor->next;
 310
 311             predecessor->next = MKBADDR(newEntry);
 312
 313             pathEntry = newEntry;
 314         }
 315         else
 316         {
 317             if (lock != BNULL)
 318             {
 319                 if (!isDirectory)
 320                 {
 321                     PrintFault(ERROR_OBJECT_WRONG_TYPE, pathName);
 322                 }
 323
 324                 UnLock(lock);
 325             }
 326
 327             if (newEntry != NULL)
 328             {
 329                 FreeVec(newEntry);
 330             }
 331         }
 332     }
 333
 334     return(pathEntry);
 335 }
 336
 337
 338 /* check if the object specified is a directory */
 339 static BOOL
 340 IsDirectory(BPTR lock, APTR DOSBase)
 341 {
 342         BOOL
 343     isDirectory = FALSE;
 344
 345         struct FileInfoBlock*
 346     fib = AllocDosObject(DOS_FIB, NULL);
 347
 348     if (Examine(lock, fib))
 349     {
 350             LONG
 351         entryType = fib->fib_EntryType;
 352
 353         if (entryType >= ST_ROOT && entryType <= ST_LINKDIR)
 354         {
 355             if (entryType != ST_SOFTLINK)
 356             {
 357                 isDirectory = TRUE;
 358             }
 359             else
 360             {
 361                     BPTR
 362                 dupLock = DupLock(lock);
 363
 364                 if (BNULL != dupLock)
 365                 {
 366                         BPTR
 367                     file = OpenFromLock(dupLock);
 368
 369                     if (BNULL != file)
 370                     {
 371 /* lock was on a file. dupLock is relinquished by OpenFromLock */
 372                         Close(file);
 373
 374                         isDirectory = FALSE;
 375                     }
 376                     else
 377                     {
 378                         UnLock(dupLock);
 379                     }
 380                 }
 381                 else
 382                 {
 383                     isDirectory = FALSE;
 384                 }
 385             }
 386         }
 387
 388         FreeDosObject(DOS_FIB, fib);
 389     }
 390
 391     return(isDirectory);
 392 }