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     EXAMPLE
  49
  50     BUGS
  51
  52     SEE ALSO
  53
  54     INTERNALS
  55
  56         Executable files in AROS currently haven't got the e-flag set,
  57         which makes Which unusable for now in emulated mode.
  58
  59     HISTORY
  60
  61
  62 ******************************************************************************/
  63
  64 #include <aros/debug.h>
  65 #include <proto/exec.h>
  66 #include <proto/dos.h>
  67 #include <exec/memory.h>
  68 #include <dos/dosextens.h>
  69 #include <utility/tagitem.h>
  70
  71 #define  ARG_COUNT  4    /* Number of ReadArgs() arguments */
  72
  73 const TEXT version[] = "$VER: Which 41.2 (13.2.2016)";
  74
  75 /* NOTE: For now, compatibility to the Amiga Which command is kept, but
  76          I think that the restriction to only executable files should be
  77          removed, especially considering soft links and such. */
  78
  79
  80 /*
  81  * Check the resident list for the command 'name'.
  82  */
  83 static BOOL FindResidentCommand(STRPTR name);
  84
  85
  86 /*
  87  * Check the paths for the command 'name'.
  88  */
  89 static BOOL FindCommandinPath(STRPTR name, BOOL checkAll, struct FileInfoBlock *fib);
  90
  91
  92 /*
  93  * Check the C: multiassign for the command 'name'.
  94  */
  95 static BOOL FindCommandinC(STRPTR name, BOOL checkAll, struct FileInfoBlock *fib);
  96
  97
  98 /*
  99  * Look in the current directory for the command 'name'.
 100  */
 101 static BOOL CheckDirectory(STRPTR name, struct FileInfoBlock *fib);
 102
 103
 104 /*
 105  * Get a string that specifies the full path to a file or NULL if there
 106  * was not enough memory to allocate the string. This string should be
 107  * freed using FreeVec().
 108  */
 109 static STRPTR GetFullPath(BPTR lock);
 110
 111
 112 int __nocommandline;
 113
 114 int main(void)
 115 {
 116     /* Array filled by ReadArgs() call */
 117     IPTR           args[ARG_COUNT] = {0, 0, 0, 0};
 118
 119     struct RDArgs *rda;           /* ReadArgs standard struct */
 120     BOOL   found = FALSE;         /* Indicates whether we've found a file
 121                                      or not -- used for ALL ReadArgs() tag. */
 122     int    error = RETURN_WARN;     /* Error value to return */
 123
 124     struct FileInfoBlock *fib;    /* Used in Examine(). Allocated at top level
 125                                      to skip multiple calls to
 126                                      AllocDosObject() / FreeDosObject */
 127
 128     if((rda = ReadArgs("FILE/A,NORES/S,RES/S,ALL/S", args, NULL)) != NULL)
 129     {
 130         BOOL    noRes    = (BOOL)args[1];   /* Don't check resident commands */
 131         BOOL    resOnly  = (BOOL)args[2];   /* Check resident commands only */
 132         BOOL    checkAll = (BOOL)args[3];   /* Check for multiple occurances */
 133
 134         STRPTR  commandName = (STRPTR)args[0];     /* Command to look for */
 135
 136         fib = AllocDosObject(DOS_FIB, NULL);
 137
 138         if(fib != NULL)
 139         {
 140             if(!noRes)
 141             {
 142                 /* Check resident lists */
 143                 found |= FindResidentCommand(commandName);
 144                 D(bug("Resident list\n"));
 145             }
 146
 147             if(!found && !resOnly)
 148             {
 149                 /* Check all available paths */
 150                 found |= FindCommandinPath(commandName, checkAll, fib);
 151                 D(bug("Path\n"));
 152             }
 153
 154             if(!found && !resOnly)
 155             {
 156                 /* Check C: multiassign */
 157                 found |= FindCommandinC(commandName, checkAll, fib);
 158                 D(bug("C:\n"));
 159             }
 160             if (found)
 161             {
 162                 error = RETURN_OK;
 163             }
 164
 165             FreeDosObject(DOS_FIB, fib);
 166         }
 167
 168         FreeArgs(rda);
 169     }
 170     else
 171     {
 172         PrintFault(IoErr(), "Which");
 173         error = RETURN_FAIL;
 174     }
 175
 176     return error;
 177 }
 178
 179
 180 /* NOTE: The filesystemtask stuff is only necessary for this to work
 181          correctly on AmigaOS. AROS doesn't use this concept. */
 182 static BOOL FindCommandinC(STRPTR name, BOOL checkAll, struct FileInfoBlock *fib)
 183 {
 184     BOOL            found = FALSE;    /* Object found? */
 185     struct DevProc *dp = NULL;        /* For GetDeviceProc() call */
 186     BPTR            oldCurDir;        /* Temporary holder of old current dir */
 187     // struct MsgPort *oldFST;        /* Temporary holder of old FileSysTask */
 188
 189     /* If FilePart(name) is not name itself, it can't be in the C: directory;
 190        or rather, it isn't in the C: directory or we found it in
 191        FindCommandinPath(). */
 192     if(FilePart(name) != name)
 193         return FALSE;
 194
 195     oldCurDir = CurrentDir(BNULL);     /* Just to save the old current dir... */
 196     // oldFST    = GetFileSysTask();  /* ... and the filesystem task */
 197
 198     while(((dp = GetDeviceProc("C:", dp)) != NULL) && (!found || checkAll))
 199     {
 200         // SetFileSysTask(dp2->dvp_Port);
 201         CurrentDir(dp->dvp_Lock);
 202         found |= CheckDirectory(name, fib);
 203
 204         /* Is this a multi assign? */
 205         if(!(dp->dvp_Flags & DVPF_ASSIGN))
 206             break;
 207     }
 208
 209     // SetFileSysTask(oldFST);
 210     CurrentDir(oldCurDir);
 211     FreeDeviceProc(dp);
 212
 213     return found;
 214 }
 215
 216
 217 static BOOL FindCommandinPath(STRPTR name, BOOL checkAll, struct FileInfoBlock *fib)
 218 {
 219     BOOL  found;                /* Have we found the 'file' yet? */
 220     BPTR  oldCurDir;            /* Space to store the current dir */
 221     BPTR *paths;                /* Loop variable */
 222
 223     struct CommandLineInterface *cli = Cli();
 224     D(bug("checkAll = %ld\n", checkAll));
 225     /* Can this happen at all? */
 226     if(cli == NULL)
 227         return FALSE;
 228
 229     /* Check the current directory */
 230     D(bug("Calling CheckDirectory()\n"));
 231     found = CheckDirectory(name, fib);
 232
 233     oldCurDir = CurrentDir(BNULL);
 234
 235     /* Check all paths */
 236     paths = (BPTR *)BADDR(cli->cli_CommandDir);
 237     D(bug("paths = 0x%08lx\n", paths));
 238
 239     while((!found || checkAll) && (paths != NULL))
 240     {
 241         CurrentDir(paths[1]);
 242
 243         D(bug("Calling CheckDirectory()\n"));
 244         found |= CheckDirectory(name, fib);
 245
 246         paths = (BPTR *)BADDR(paths[0]);    /* Go on with the next path */
 247     }
 248
 249     CurrentDir(oldCurDir);
 250
 251     return found;
 252 }
 253
 254
 255 static BOOL CheckDirectory(STRPTR name, struct FileInfoBlock *fib)
 256 {
 257     BPTR    lock;                     /* Lock on 'name' */
 258     BOOL    found = FALSE;            /* For return value purposes */
 259     STRPTR  pathName;
 260
 261     lock = Lock(name, SHARED_LOCK);
 262
 263     D(bug("Locked command %s\n", name));
 264
 265     if(lock != BNULL)
 266     {
 267         D(bug("Calling Examine()\n"));
 268
 269         if(Examine(lock, fib) == DOSTRUE)
 270         {
 271             D(bug("Calling GetFullPath()\n"));
 272
 273             pathName = GetFullPath(lock);
 274
 275             if(pathName != NULL)
 276             {
 277                 /* File or directory? */
 278                 if(fib->fib_DirEntryType < 0)
 279                 {
 280                     /* FIBF_EXECUTE is active low! */
 281                     if(!(fib->fib_Protection & FIBF_EXECUTE))
 282                     {
 283                         Printf("%s\n", pathName);
 284                         found = TRUE;
 285                     }
 286                 }
 287
 288                 FreeVec(pathName); /* Free memory holding the full path name */
 289             }
 290         }
 291
 292         UnLock(lock);
 293     }
 294
 295     return found;
 296 }
 297
 298
 299 static STRPTR GetFullPath(BPTR lock)
 300 {
 301     UBYTE  *buf;           /* Pointer to the memory allocated for the string */
 302     ULONG   size;          /* Holder of the (growing) size of the string */
 303
 304     for(size = 512; ; size += 512)
 305     {
 306         buf = AllocVec(size, MEMF_ANY);
 307
 308         if(buf == NULL)
 309             break;
 310
 311         if(NameFromLock(lock, buf, size))
 312         {
 313             return (STRPTR)buf;
 314         }
 315
 316         FreeVec(buf);
 317     }
 318
 319     return NULL;
 320 }
 321
 322
 323 static BOOL FindResidentCommand(STRPTR name)
 324 {
 325     BOOL   found = FALSE;          /* For return value purposes */
 326     struct Segment *seg;           /* Holder of segment if 'name' is a
 327                                       resident command */
 328
 329     /* Look in both system and normal list. Or rather, in the normal list
 330        ONLY if it wasn't found in the system list. This is what the Amiga
 331        Which does thus not giving the whole picture if you have 'cmd'
 332        resident while 'cmd' is an internal command also. However, if this
 333        is the case, you may never access it as the system list is searched
 334         first by the Shell? */
 335     if((seg = FindSegment(name, NULL, TRUE)) == NULL)
 336     {
 337         seg = FindSegment(name, NULL, FALSE);
 338     }
 339
 340     if(seg != NULL)
 341     {
 342         found = TRUE;
 343
 344         if(seg->seg_UC == CMD_INTERNAL)
 345         {
 346             Printf("INTERNAL %s\n", name);
 347         }
 348         else if(seg->seg_UC == CMD_DISABLED)
 349         {
 350             Printf("INTERNAL %s ;(DISABLED)\n", name);
 351         }
 352         else
 353             Printf("RES %s\n", name);
 354     }
 355
 356     return found;
 357 }