workbench/c/shellcommands/Path.c

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