workbench/c/Which.c

   1 /*
   2     Copyright © 1995-2016, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Find the whereabouts of an executable file
   6     Lang: English
   7 */
   8
   9 /******************************************************************************
  10
  11     NAME
  12
  13         Which
  14
  15     SYNOPSIS
  16
  17         FILE/A, NORES/S, RES/S, ALL/S
  18
  19     LOCATION
  20
  21         C:
  22
  23     FUNCTION
  24
  25         Find and print the location of a specific program.
  26         Resident programs are marked as RES if they are not
  27         internal resident in which case they are marked as INTERNAL.
  28
  29         Which searches the resident list, the current directory,
  30         the command paths and the C: assign. If the item was not
  31         found the condition flag is set to WARN but no error is
  32         printed.
  33
  34     INPUTS
  35
  36         FILE   --  the command to search for
  37         NORES  --  don't include resident programs in the search
  38         RES    --  consider resident programs only
  39         ALL    --  find all locations of the FILE. This may cause the
  40                    printing of the same location several times, for
  41                    instance if the current directory is C: and the
  42                    FILE was found in C:
  43
  44     RESULT
  45
  46     NOTES
  47
  48         For compatibility reasons these cases are handled specially:
  49
  50         Absolute path:
  51             Prints the expanded path if it exists and is a file
  52             and no RES argument is given.
  53
  54         Path which ends with a ':':
  55             Prints the expanded path if it exists and no RES argument is given.
  56
  57     EXAMPLE
  58
  59     BUGS
  60
  61     SEE ALSO
  62
  63     INTERNALS
  64
  65         Executable files in AROS currently haven't got the e-flag set,
  66         which makes Which unusable for now in emulated mode.
  67
  68     HISTORY
  69
  70
  71 ******************************************************************************/
  72
  73 //#define DEBUG 1
  74 #include <aros/debug.h>
  75 #include <proto/exec.h>
  76 #include <proto/dos.h>
  77 #include <exec/memory.h>
  78 #include <dos/dosextens.h>
  79 #include <utility/tagitem.h>
  80
  81 #define  ARG_COUNT  4    /* Number of ReadArgs() arguments */
  82
  83 const TEXT version[] = "$VER: Which 41.2 (14.2.2016)";
  84
  85 /* NOTE: For now, compatibility to the Amiga Which command is kept, but
  86          I think that the restriction to only executable files should be
  87          removed, especially considering soft links and such. */
  88
  89
  90 /*
  91  * Check the resident list for the command 'name'.
  92  */
  93 static BOOL FindResidentCommand(STRPTR name);
  94
  95
  96 /*
  97  * Check the paths for the command 'name'.
  98  */
  99 static BOOL FindCommandinPath(STRPTR name, BOOL checkAll, struct FileInfoBlock *fib);
 100
 101
 102 /*
 103  * Handle absolute path for the command 'name'.
 104  */
 105
 106 static BOOL FindCommandInAbsolutePath(STRPTR name, TEXT *colon, struct FileInfoBlock *fib);
 107
 108
 109 /*
 110  * Check the C: multiassign for the command 'name'.
 111  */
 112 static BOOL FindCommandinC(STRPTR name, BOOL checkAll, struct FileInfoBlock *fib);
 113
 114
 115 /*
 116  * Look in the current directory for the command 'name'.
 117  */
 118 static BOOL CheckDirectory(STRPTR name, BOOL directory, struct FileInfoBlock *fib);
 119
 120
 121 /*
 122  * Get a string that specifies the full path to a file or NULL if there
 123  * was not enough memory to allocate the string. This string should be
 124  * freed using FreeVec().
 125  */
 126 static STRPTR GetFullPath(BPTR lock);
 127
 128
 129 int __nocommandline;
 130
 131 int main(void)
 132 {
 133     /* Array filled by ReadArgs() call */
 134     IPTR           args[ARG_COUNT] = {0, 0, 0, 0};
 135
 136     struct RDArgs *rda;           /* ReadArgs standard struct */
 137     BOOL   found = FALSE;         /* Indicates whether we've found a file
 138                                      or not -- used for ALL ReadArgs() tag. */
 139     int    error = RETURN_WARN;     /* Error value to return */
 140
 141     struct FileInfoBlock *fib;    /* Used in Examine(). Allocated at top level
 142                                      to skip multiple calls to
 143                                      AllocDosObject() / FreeDosObject */
 144
 145     if((rda = ReadArgs("FILE/A,NORES/S,RES/S,ALL/S", args, NULL)) != NULL)
 146     {
 147         BOOL    noRes    = (BOOL)args[1];   /* Don't check resident commands */
 148         BOOL    resOnly  = (BOOL)args[2];   /* Check resident commands only */
 149         BOOL    checkAll = (BOOL)args[3];   /* Check for multiple occurances */
 150
 151         STRPTR  commandName = (STRPTR)args[0];     /* Command to look for */
 152
 153         TEXT *colon;
 154
 155         fib = AllocDosObject(DOS_FIB, NULL);
 156
 157         if(fib != NULL)
 158         {
 159             if (!resOnly && (colon = strchr(commandName, ':')))
 160             {
 161                 /* Check for absolute path */
 162                 found |= FindCommandInAbsolutePath(commandName, colon, fib);
 163                 D(bug("Absolute path\n"));
 164             }
 165             else
 166             {
 167                 if(!found && !noRes)
 168                 {
 169                     /* Check resident lists */
 170                     found |= FindResidentCommand(commandName);
 171                     D(bug("Resident list\n"));
 172                 }
 173
 174                 if(!found && !resOnly)
 175                 {
 176                     /* Check all available paths */
 177                     found |= FindCommandinPath(commandName, checkAll, fib);
 178                     D(bug("Path\n"));
 179                 }
 180
 181                 if(!found && !resOnly)
 182                 {
 183                     /* Check C: multiassign */
 184                     found |= FindCommandinC(commandName, checkAll, fib);
 185                     D(bug("C:\n"));
 186                 }
 187             }
 188
 189             if (found)
 190             {
 191                 error = RETURN_OK;
 192             }
 193
 194             FreeDosObject(DOS_FIB, fib);
 195         }
 196
 197         FreeArgs(rda);
 198     }
 199     else
 200     {
 201         PrintFault(IoErr(), "Which");
 202         error = RETURN_FAIL;
 203     }
 204
 205     return error;
 206 }
 207
 208
 209 /* NOTE: The filesystemtask stuff is only necessary for this to work
 210          correctly on AmigaOS. AROS doesn't use this concept. */
 211 static BOOL FindCommandinC(STRPTR name, BOOL checkAll, struct FileInfoBlock *fib)
 212 {
 213     BOOL            found = FALSE;    /* Object found? */
 214     struct DevProc *dp = NULL;        /* For GetDeviceProc() call */
 215     BPTR            oldCurDir;        /* Temporary holder of old current dir */
 216     // struct MsgPort *oldFST;        /* Temporary holder of old FileSysTask */
 217
 218     /* If FilePart(name) is not name itself, it can't be in the C: directory;
 219        or rather, it isn't in the C: directory or we found it in
 220        FindCommandinPath(). */
 221     if(FilePart(name) != name)
 222         return FALSE;
 223
 224     oldCurDir = CurrentDir(BNULL);     /* Just to save the old current dir... */
 225     // oldFST    = GetFileSysTask();  /* ... and the filesystem task */
 226
 227     while(((dp = GetDeviceProc("C:", dp)) != NULL) && (!found || checkAll))
 228     {
 229         // SetFileSysTask(dp2->dvp_Port);
 230         CurrentDir(dp->dvp_Lock);
 231         found |= CheckDirectory(name, FALSE, fib);
 232
 233         /* Is this a multi assign? */
 234         if(!(dp->dvp_Flags & DVPF_ASSIGN))
 235             break;
 236     }
 237
 238     // SetFileSysTask(oldFST);
 239     CurrentDir(oldCurDir);
 240     FreeDeviceProc(dp);
 241
 242     return found;
 243 }
 244
 245
 246 static BOOL FindCommandinPath(STRPTR name, BOOL checkAll, struct FileInfoBlock *fib)
 247 {
 248     BOOL  found;                /* Have we found the 'file' yet? */
 249     BPTR  oldCurDir;            /* Space to store the current dir */
 250     BPTR *paths;                /* Loop variable */
 251
 252     struct CommandLineInterface *cli = Cli();
 253     D(bug("checkAll = %ld\n", checkAll));
 254     /* Can this happen at all? */
 255     if(cli == NULL)
 256         return FALSE;
 257
 258     /* Check the current directory */
 259     D(bug("Calling CheckDirectory()\n"));
 260     found = CheckDirectory(name, FALSE, fib);
 261
 262     oldCurDir = CurrentDir(BNULL);
 263
 264     /* Check all paths */
 265     paths = (BPTR *)BADDR(cli->cli_CommandDir);
 266     D(bug("paths = 0x%08lx\n", paths));
 267
 268     while((!found || checkAll) && (paths != NULL))
 269     {
 270         CurrentDir(paths[1]);
 271
 272         D(bug("Calling CheckDirectory()\n"));
 273         found |= CheckDirectory(name, FALSE, fib);
 274
 275         paths = (BPTR *)BADDR(paths[0]);    /* Go on with the next path */
 276     }
 277
 278     CurrentDir(oldCurDir);
 279
 280     return found;
 281 }
 282
 283
 284 static BOOL FindCommandInAbsolutePath(STRPTR name, TEXT *colon, struct FileInfoBlock *fib)
 285 {
 286     BOOL  found;                /* Have we found the 'file' yet? */
 287
 288     if (*(colon + 1) == '\0')
 289     {
 290         /* In case path ends with ':' we print the directory */
 291         D(bug("Path ends with ':'\n"));
 292         /* Check the current directory */
 293         D(bug("Calling CheckDirectory()\n"));
 294         found = CheckDirectory(name, TRUE, fib);
 295     }
 296     else
 297     {
 298         /* Check the current directory */
 299         D(bug("Calling CheckDirectory()\n"));
 300         found = CheckDirectory(name, FALSE, fib);
 301     }
 302
 303     return found;
 304 }
 305
 306
 307 static BOOL CheckDirectory(STRPTR name, BOOL directory, struct FileInfoBlock *fib)
 308 {
 309     BPTR    lock;                     /* Lock on 'name' */
 310     BOOL    found = FALSE;            /* For return value purposes */
 311     STRPTR  pathName;
 312
 313     lock = Lock(name, SHARED_LOCK);
 314
 315     D(bug("Locked command %s\n", name));
 316
 317     if(lock != BNULL)
 318     {
 319         D(bug("Calling Examine()\n"));
 320
 321         if(Examine(lock, fib) == DOSTRUE)
 322         {
 323             D(bug("Calling GetFullPath()\n"));
 324
 325             pathName = GetFullPath(lock);
 326
 327             if(pathName != NULL)
 328             {
 329                 /* File or directory? */
 330                 if(fib->fib_DirEntryType < 0)
 331                 {
 332                     /* FIBF_EXECUTE is active low! */
 333                     if(!(fib->fib_Protection & FIBF_EXECUTE))
 334                     {
 335                         Printf("%s\n", pathName);
 336                         found = TRUE;
 337                     }
 338                 }
 339                 else if (directory)
 340                 {
 341                     Printf("%s\n", pathName);
 342                     found = TRUE;
 343                 }
 344
 345                 FreeVec(pathName); /* Free memory holding the full path name */
 346             }
 347         }
 348
 349         UnLock(lock);
 350     }
 351
 352     return found;
 353 }
 354
 355
 356 static STRPTR GetFullPath(BPTR lock)
 357 {
 358     UBYTE  *buf;           /* Pointer to the memory allocated for the string */
 359     ULONG   size;          /* Holder of the (growing) size of the string */
 360
 361     for(size = 512; ; size += 512)
 362     {
 363         buf = AllocVec(size, MEMF_ANY);
 364
 365         if(buf == NULL)
 366             break;
 367
 368         if(NameFromLock(lock, buf, size))
 369         {
 370             return (STRPTR)buf;
 371         }
 372
 373         FreeVec(buf);
 374     }
 375
 376     return NULL;
 377 }
 378
 379
 380 static BOOL FindResidentCommand(STRPTR name)
 381 {
 382     BOOL   found = FALSE;          /* For return value purposes */
 383     struct Segment *seg;           /* Holder of segment if 'name' is a
 384                                       resident command */
 385
 386     /* Look in both system and normal list. Or rather, in the normal list
 387        ONLY if it wasn't found in the system list. This is what the Amiga
 388        Which does thus not giving the whole picture if you have 'cmd'
 389        resident while 'cmd' is an internal command also. However, if this
 390        is the case, you may never access it as the system list is searched
 391         first by the Shell? */
 392     if((seg = FindSegment(name, NULL, TRUE)) == NULL)
 393     {
 394         seg = FindSegment(name, NULL, FALSE);
 395     }
 396
 397     if(seg != NULL)
 398     {
 399         found = TRUE;
 400
 401         if(seg->seg_UC == CMD_INTERNAL)
 402         {
 403             Printf("INTERNAL %s\n", name);
 404         }
 405         else if(seg->seg_UC == CMD_DISABLED)
 406         {
 407             Printf("INTERNAL %s ;(DISABLED)\n", name);
 408         }
 409         else
 410             Printf("RES %s\n", name);
 411     }
 412
 413     return found;
 414 }