workbench/c/Which.c

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