workbench/c/Dir.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Dir CLI command
   6     Lang: English
   7 */
   8
   9 #define MAX_PATH_LEN                    512
  10
  11 #define USE_SOFTLINKCHECK               0
  12
  13 #include <exec/devices.h>
  14 #include <exec/io.h>
  15 #include <exec/memory.h>
  16 #include <exec/semaphores.h>
  17 #include <dos/dos.h>
  18 #include <dos/exall.h>
  19 #include <dos/datetime.h>
  20 #include <utility/tagitem.h>
  21 #include <utility/utility.h>
  22
  23 #include <aros/asmcall.h>
  24 #include <aros/debug.h>
  25
  26 #include <proto/exec.h>
  27 #include <proto/dos.h>
  28 #include <proto/utility.h>
  29
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <memory.h>
  33
  34 //#include <stdio.h>
  35
  36 /******************************************************************************
  37
  38
  39     NAME
  40
  41     Dir [(dir | pattern)] [OPT A | I | D | F] [ALL] [DIRS] [FILES] [INTER]
  42
  43
  44     SYNOPSIS
  45
  46     DIR,OPT/K,ALL/S,DIRS/S,FILES/S,INTER/S
  47
  48     LOCATION
  49
  50     Sys:C
  51
  52     FUNCTION
  53
  54     DIR displays the file or directory contained in the current or
  55     specified directory. Directories get listed first, then in alphabetical
  56     order, the files are listed in two columns. Pressing CTRL-C aborts the
  57     directory listing.
  58
  59
  60     INPUTS
  61
  62     ALL    --  Display all subdirectories and their files recursively.
  63     DIRS   --  Display only directories.
  64     FILES  --  Display only files.
  65     INTER  --  Enter interactive mode.
  66
  67                Interactive listing mode stops after each name to display
  68                a question mark at which you can enter commands. These
  69                commands are:
  70
  71                Return      --  Goto the next file or directory.
  72                E/ENTER     --  Enters a directory.
  73                DEL/DELETE  --  Delete a file or an empty directory.
  74                C/COM       --  Let the file or directory be the input of
  75                                a DOS command (which specified after the C or
  76                                COM or specified separately later).
  77                Q/QUIT      --  Quit interactive mode.
  78                B/BACK      --  Go back one directory level.
  79
  80     RESULT
  81
  82     NOTES
  83
  84     EXAMPLE
  85
  86     BUGS
  87
  88     SEE ALSO
  89
  90     INTERNALS
  91
  92     HISTORY
  93
  94     XY.11.2000  SDuvan  added pattern matching support and support for
  95                         FILES/S, DIRS/S and OPT/K and some support for
  96                         INTER/S. Complete interactive support is still missing.
  97
  98 ******************************************************************************/
  99
 100 #define VERSTAG "\0$VER: Dir 50.8 (27.11.2004)"
 101
 102 const TEXT version[] = VERSTAG;
 103
 104 struct table
 105 {
 106     char **entries;
 107     int    num;
 108     int    max;
 109 };
 110
 111
 112 struct data
 113 {
 114     struct ExecBase     *SysBase;
 115     struct DosLibrary   *DOSBase;
 116     struct Library      *UtilityBase;
 117     int                 g_indent;
 118 };
 119
 120 #define SysBase         data->SysBase
 121 #define DOSBase         data->DOSBase
 122 #define UtilityBase     data->UtilityBase
 123 #define g_indent        data->g_indent
 124
 125
 126 /*  Prototypes  */
 127
 128 static
 129 LONG doPatternDir(STRPTR dirPat, BOOL all, BOOL doDirs, BOOL doFiles,
 130                   BOOL inter, struct data *data);
 131 static
 132 LONG doDir(STRPTR dir, BOOL all, BOOL dirs, BOOL files, BOOL inter, struct data *data);
 133
 134 static
 135 void showline(char *fmt, IPTR *args, struct data *data);
 136 static
 137 void maybeShowline(char *format, IPTR *args, BOOL doIt, BOOL inter, struct data *data);
 138 static
 139 void maybeShowlineCR(char *format, IPTR *args, BOOL doIt, BOOL inter, struct data *data);
 140
 141 static
 142 int CheckDir(BPTR lock, struct ExAllData *ead, ULONG eadSize,
 143              struct ExAllControl *eac, struct table *dirs,
 144              struct table *files, struct data *data);
 145
 146
 147 #define  INTERARG_TEMPLATE  "E=ENTER/S,B=BACK/S,DEL=DELETE/S,Q=QUIT/S,C=COM/S,COMMAND"
 148
 149 enum
 150 {
 151     INTERARG_ENTER = 0,
 152     INTERARG_BACK,
 153     INTERARG_DELETE,
 154     INTERARG_QUIT,
 155     INTERARG_COM,
 156     INTERARG_COMMAND,
 157     NOOFINTERARGS
 158 };
 159
 160 #define  ARG_TEMPLATE  "DIR,OPT/K,ALL/S,DIRS/S,FILES/S,INTER/S"
 161
 162 enum
 163 {
 164     ARG_DIR = 0,
 165     ARG_OPT,
 166     ARG_ALL,
 167     ARG_DIRS,
 168     ARG_FILES,
 169     ARG_INTER
 170 };
 171
 172 AROS_UFH3(__startup static int, Start,
 173           AROS_UFHA(char *, argstr, A0),
 174           AROS_UFHA(ULONG, argsize, D0),
 175           AROS_UFHA(struct ExecBase *, sBase, A6))
 176 {
 177     AROS_USERFUNC_INIT
 178
 179     struct data _data, *data = &_data;
 180     struct RDArgs *rda;
 181     IPTR           args[] = { (IPTR)NULL, (IPTR)NULL, (IPTR)FALSE, (IPTR)FALSE, (IPTR)FALSE, (IPTR)FALSE };
 182
 183     LONG error = RETURN_FAIL;
 184
 185     SysBase = sBase;
 186     if ((DOSBase=(struct DosLibrary *)OpenLibrary("dos.library",37)))
 187     {
 188         if ((UtilityBase=OpenLibrary("utility.library",37)))
 189         {
 190             error = RETURN_ERROR;
 191
 192             rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 193
 194             if (rda != NULL)
 195             {
 196                 STRPTR dir = (STRPTR)args[ARG_DIR];
 197                 STRPTR opt = (STRPTR)args[ARG_OPT];
 198                 BOOL   all = (BOOL)args[ARG_ALL];
 199                 BOOL   dirs = (BOOL)args[ARG_DIRS];
 200                 BOOL   files = (BOOL)args[ARG_FILES];
 201                 BOOL   inter = (BOOL)args[ARG_INTER];
 202
 203                 LONG iswild;
 204
 205                 g_indent = 0;
 206
 207                 /* Convert the OPT arguments (if any) into the regular switches */
 208                 if (opt != NULL)
 209                 {
 210                     while (*opt != 0)
 211                     {
 212                         switch (ToUpper(*opt))
 213                         {
 214                         case 'D':
 215                             dirs = TRUE;
 216                             break;
 217
 218                         case 'F':
 219                             files = TRUE;
 220                             break;
 221
 222                         case 'A':
 223                             all = TRUE;
 224                             break;
 225
 226                         case 'I':
 227                             inter = TRUE;
 228                             break;
 229
 230                         default:
 231                             Printf("%lc option ignored\n", *opt);
 232                             break;
 233                         }
 234                         opt++;
 235                     }
 236                 }
 237
 238                 if(dir == NULL)
 239                 {
 240                     dir = "";
 241                     iswild = 0;
 242                 }
 243                 else
 244                 {
 245                     ULONG toklen = strlen(dir) * 2;
 246                     STRPTR pattok = AllocMem(toklen, MEMF_PUBLIC | MEMF_ANY);
 247                     iswild = ParsePattern(dir, pattok, toklen);
 248                     FreeMem(pattok, toklen);
 249                 }
 250
 251                 if(!files && !dirs)
 252                 {
 253                     files = TRUE;
 254                     dirs  = TRUE;
 255                 }
 256
 257
 258                 if (iswild == 1)
 259                 {
 260                     error = doPatternDir(dir, all, dirs, files, inter, data);
 261                 }
 262                 else
 263                 {
 264                     error = doDir(dir, all, dirs, files, inter, data);
 265                 }
 266
 267                 if (error != RETURN_OK)
 268                 {
 269                     LONG ioerr = IoErr();
 270                     switch (ioerr)
 271                     {
 272                     case ERROR_NO_MORE_ENTRIES:
 273                         ioerr = 0;
 274                         break;
 275                     case ERROR_OBJECT_WRONG_TYPE:
 276                         Printf("%s is not a directory\n", (IPTR)dir);
 277                         ioerr = ERROR_DIR_NOT_FOUND;
 278                         break;
 279                     default:
 280                         Printf("Could not get information for %s\n", (IPTR)dir);
 281                     }
 282                     PrintFault(ioerr, NULL);
 283                 }
 284
 285                 FreeArgs(rda);
 286             }
 287             else
 288             {
 289                 PrintFault(IoErr(), NULL);
 290             }
 291
 292             CloseLibrary((struct Library *)UtilityBase);
 293         }
 294         CloseLibrary((struct Library *)DOSBase);
 295     }
 296
 297     return error;
 298
 299     AROS_USERFUNC_EXIT
 300 }
 301
 302 static
 303 int AddEntry(struct table *table, char *entry, struct data *data)
 304 {
 305     char *dup;
 306     int len;
 307
 308     if (table->num == table->max)
 309     {
 310         int    new_max = table->max + 128;
 311         char **new_entries;
 312
 313         new_entries = AllocVec(sizeof(char *) * new_max, MEMF_ANY);
 314
 315         if (new_entries == NULL)
 316             return 0;
 317
 318         if (table->num)
 319         {
 320             CopyMemQuick(table->entries, new_entries,
 321                          sizeof(char *) * table->num);
 322             FreeVec(table->entries);
 323         }
 324
 325         table->entries = new_entries;
 326         table->max = new_max;
 327     }
 328
 329     len = strlen(entry) + 1;
 330     if ((dup = AllocVec(len,MEMF_ANY)))
 331     {
 332         strcpy(dup,entry);
 333     }
 334     else
 335     {
 336         return 0;
 337     }
 338     table->entries[table->num++] = dup;
 339
 340     return 1;
 341 }
 342
 343
 344 static __inline
 345 int mystrcasecmp(const char *s1, const char *s2)
 346 {
 347     int a, b;
 348
 349     do
 350     {
 351         a = *s1++;
 352         b = *s2++;
 353
 354         if (a >= 'a' && a <= 'z') a -= 'a' - 'A';
 355         if (b >= 'a' && b <= 'z') b -= 'a' - 'A';
 356
 357         a -= b;
 358         if (a) return (int) a;
 359
 360     } while (b);
 361
 362     return 0;
 363 }
 364
 365 static
 366 int compare_strings(const void * s1, const void * s2)
 367 {
 368     return mystrcasecmp(*(char **)s1, *(char **)s2);
 369 }
 370
 371
 372 static
 373 void maybeShowlineCR(char *format, IPTR *args, BOOL doIt, BOOL inter, struct data *data)
 374 {
 375     maybeShowline(format, args, doIt, inter, data);
 376
 377     if (!inter)
 378     {
 379         PutStr("\n");
 380     }
 381 }
 382
 383
 384
 385 static
 386 void maybeShowline(char *format, IPTR *args, BOOL doIt, BOOL inter, struct data *data)
 387 {
 388     if(doIt)
 389     {
 390         showline(format, args, data);
 391
 392 #if 0
 393         if(inter)
 394         {
 395             struct ReadArgs *rda;
 396
 397             IPTR  interArgs[NOOFINTERARGS] = { (IPTR)FALSE,
 398                                                (IPTR)FALSE,
 399                                                (IPTR)FALSE,
 400                                                (IPTR)FALSE,
 401                                                (IPTR)FALSE,
 402                                                NULL };
 403
 404             rda = ReadArgs(INTERARG_TEMPLATE, interArgs, NULL);
 405
 406             if (rda != NULL)
 407             {
 408                 if (interArgs[ARG_ENTER])
 409                 {
 410                     return c_Enter;
 411                 }
 412                 else if (interArgs[ARG_BACK])
 413                 {
 414                     return c_Back;
 415                 }
 416                 else if (interArgs[ARG_DELETE])
 417                 {
 418                     return c_Delete;
 419                 }
 420                 else if (interArgs[ARG_QUIT])
 421                 {
 422                     return c_Quit;
 423                 }
 424                 else if (interArgs[ARG_COM])
 425                 {
 426                     return c_Com;
 427                 }
 428                 else if (interArgs[ARG_COMMAND] != NULL)
 429                 {
 430                     command =
 431                         return c_Command;
 432                 }
 433             }
 434         }
 435 #endif
 436
 437     }
 438 }
 439
 440
 441 static
 442 void showline(char *fmt, IPTR *args, struct data *data)
 443 {
 444     int t;
 445
 446     for (t = 0; t < g_indent; t++)
 447         PutStr("     ");
 448
 449     VPrintf(fmt, args);
 450 }
 451
 452 // Returns TRUE if all lines shown, FALSE if broken by SIGBREAKF_CTRL_C
 453 static
 454 BOOL showfiles(struct table *files, BOOL inter, struct data *data)
 455 {
 456     IPTR argv[2];
 457     ULONG t;
 458
 459     qsort(files->entries, files->num, sizeof(char *),compare_strings);
 460
 461     for (t = 0; t < files->num; t += 2)
 462     {
 463         argv[0] = (IPTR)(files->entries[t]);
 464         argv[1] = (IPTR)(t + 1 < files->num ? files->entries[t+1] : "");
 465
 466         if (SetSignal(0L,SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
 467         {
 468             SetIoErr(ERROR_BREAK);
 469             return FALSE;
 470         }
 471
 472         maybeShowlineCR("  %-32.s %s", argv, TRUE, inter, data);
 473     }
 474     return TRUE;
 475 }
 476
 477 static
 478 BOOL showdir(char *dirName, BOOL inter, struct data *data)
 479 {
 480     IPTR argv[1] = {(IPTR)dirName};
 481     maybeShowlineCR("%s (dir)", argv, TRUE, inter, data);
 482     return TRUE;
 483 }
 484
 485 static
 486 LONG doPatternDir(STRPTR dirPat, BOOL all, BOOL doDirs, BOOL doFiles, BOOL inter, struct data *data)
 487 {
 488     struct table files;
 489     struct AnchorPath *ap;      /* Matching structure */
 490
 491     LONG  match;                /* Loop variable */
 492     LONG  error = RETURN_FAIL;
 493
 494     LONG  ioerr = 0;
 495
 496     files.entries = NULL;
 497     files.max = 0;
 498     files.num = 0;
 499
 500     ap = (struct AnchorPath *)AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN, MEMF_CLEAR);
 501
 502     if(ap != NULL)
 503     {
 504         ap->ap_Strlen = MAX_PATH_LEN;
 505         ap->ap_BreakBits = SIGBREAKF_CTRL_C;
 506
 507         if ((match = MatchFirst(dirPat, ap)) == 0)
 508         {
 509             error = RETURN_OK;
 510             g_indent++;
 511             for (;;)
 512             {
 513 #if USE_SOFTLINKCHECK
 514                 if (SoftlinkDODIR(ap, TRUE, FALSE, DOSBase))
 515 #else /* USE_SOFTLINKCHECK */
 516                 if (ap->ap_Info.fib_DirEntryType > 0)
 517 #endif /* USE_SOFTLINKCHECK */
 518                 {
 519                     if (doDirs)
 520                     {
 521                         BPTR l = Lock(ap->ap_Buf, SHARED_LOCK);
 522                         if (l != NULL)
 523                         {
 524                             UBYTE name[512];
 525                             name[0] = 0;
 526                             NameFromLock(l, name, 512);
 527                             UnLock(l);
 528                             showdir(name, inter, data);
 529                         }
 530                     }
 531                     if (all)
 532                     {
 533                         error = doDir(ap->ap_Buf, all, doDirs, doFiles, inter, data);
 534                     }
 535                 }
 536                 else if (doFiles)
 537                 {
 538                     if (!AddEntry(&files, ap->ap_Info.fib_FileName, data))
 539                     {
 540                         ioerr = ERROR_NO_FREE_STORE;
 541                         error = RETURN_FAIL;
 542                         break;
 543                     }
 544                 }
 545                 ioerr = IoErr();
 546
 547                 if (error != RETURN_OK)
 548                 {
 549                     break;
 550                 }
 551                 ap->ap_Strlen = MAX_PATH_LEN;
 552                 match = MatchNext(ap);
 553                 if (match != 0)
 554                     break;
 555             }
 556             g_indent--;
 557             if (error == RETURN_OK && files.num != 0)
 558             {
 559                 if (!showfiles(&files, inter, data))
 560                 {
 561                     error = RETURN_FAIL;
 562                 }
 563
 564             }
 565             MatchEnd(ap);
 566         }
 567         else
 568         {
 569             ioerr = match;
 570             error = RETURN_FAIL;
 571         }
 572         FreeVec(ap);
 573     }
 574
 575     SetIoErr(ioerr);
 576
 577     return error;
 578 }
 579
 580
 581
 582
 583 static
 584 LONG doDir(STRPTR dir, BOOL all, BOOL doDirs, BOOL doFiles, BOOL inter, struct data *data)
 585 {
 586     BPTR  lock;
 587     static UBYTE buffer[4096];
 588     struct ExAllControl  *eac;
 589     LONG error = RETURN_OK;
 590
 591     struct table  dirs;
 592     struct table  files;
 593
 594     dirs.entries = files.entries = NULL;
 595     dirs.max = files.max = 0;
 596     dirs.num = files.num = 0;
 597
 598     lock = Lock(dir, SHARED_LOCK);
 599
 600     if (lock != NULL)
 601     {
 602         eac = AllocDosObject(DOS_EXALLCONTROL, NULL);
 603
 604         if (eac != NULL)
 605         {
 606             int t;
 607
 608             eac->eac_LastKey = 0;
 609
 610             error = CheckDir(lock, (struct ExAllData *)buffer, sizeof(buffer), eac, &dirs, &files, data);
 611             FreeDosObject(DOS_EXALLCONTROL, eac);
 612
 613             if (SetSignal(0L,SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
 614             {
 615                 SetIoErr(ERROR_BREAK);
 616                 error = RETURN_FAIL;
 617             }
 618
 619             if (error == 0 && doDirs)
 620             {
 621                 if (dirs.num != 0)
 622                 {
 623                     g_indent++;
 624
 625                     //qsort(dirs.entries, dirs.num, sizeof(char *), compare_strings);
 626
 627                     // Output the directories
 628                     for (t = 0; t < dirs.num; t++)
 629                     {
 630                         STRPTR dirname = dirs.entries[t];
 631
 632                         // Recurse into subdirectories if "ALL" was specified by the user
 633                         if (all)
 634                         {
 635                             char *newpath;
 636                             int len;
 637                             int pathlen = strlen(dir);
 638
 639                             len = pathlen + strlen(dirs.entries[t]) + 2;
 640                             newpath = AllocVec(len, MEMF_ANY);
 641
 642                             if (newpath != NULL)
 643                             {
 644                                 CopyMem(dir, newpath, pathlen + 1);
 645                                 if (AddPart(newpath, dirs.entries[t], len))
 646                                 {
 647                                     if (doDirs)
 648                                         showdir(dirname, inter, data);
 649                                     error = doDir(newpath, all, doDirs, doFiles, inter, data);
 650                                 }
 651                                 else
 652                                 {
 653                                     SetIoErr(ERROR_LINE_TOO_LONG);
 654                                     error = RETURN_ERROR;
 655                                 }
 656                                 FreeVec(newpath);
 657                             }
 658                             else
 659                             {
 660                                 SetIoErr(ERROR_NO_FREE_STORE);
 661                                 error = RETURN_FAIL;
 662                             }
 663                             if (error != RETURN_OK)
 664                                 break;
 665                         }
 666                         else if (doDirs)
 667                         {
 668                             showdir(dirname, inter, data);
 669                         }
 670                     }
 671                     g_indent--;
 672                 }
 673             }
 674
 675             // Output the files
 676             if (error == RETURN_OK && (files.num != 0 && doFiles))
 677             {
 678                 if (!showfiles(&files, inter, data))
 679                 {
 680                     error = RETURN_FAIL;
 681                 }
 682
 683             }
 684
 685             if (dirs.num != 0)
 686             {
 687                 for (t = 0; t < dirs.num; t++)
 688                 {
 689                     FreeVec(dirs.entries[t]);
 690                 }
 691
 692                 if (dirs.entries)
 693                 {
 694                     FreeVec(dirs.entries);
 695                 }
 696             }
 697
 698             if (files.num != 0)
 699             {
 700                 for (t = 0; t < files.num; t++)
 701                 {
 702                     FreeVec(files.entries[t]);
 703                 }
 704
 705                 if (files.entries)
 706                 {
 707                     FreeVec(files.entries);
 708                 }
 709             }
 710
 711         }
 712         else
 713         {
 714             SetIoErr(ERROR_NO_FREE_STORE);
 715             error = RETURN_FAIL;
 716         }
 717
 718         UnLock(lock);
 719     }
 720     else
 721     {
 722 #if USE_SOFTLINKCHECK
 723
 724         struct DevProc *dvp;
 725         LONG ioerr;
 726
 727         error = RETURN_FAIL;
 728         ioerr = IoErr();
 729
 730         if (ioerr == ERROR_OBJECT_NOT_FOUND &&
 731             (dvp = GetDeviceProc(dir, NULL)))
 732         {
 733             if (ReadLink(dvp->dvp_Port, dvp->dvp_Lock, dir, buffer, sizeof(buffer) - 1) > 0)
 734             {
 735                 buffer[sizeof(buffer) - 1] = '\0';
 736
 737                 Printf("Warning: Skipping dangling softlink %s -> %s\n",
 738                        (LONG) dir, (LONG) buffer);
 739
 740                 error = RETURN_OK;
 741             }
 742
 743             FreeDeviceProc(dvp);
 744         }
 745
 746         SetIoErr(ioerr);
 747
 748 #else /* USE_SOFTLINKCHECK */
 749
 750         error = RETURN_FAIL;
 751
 752 #endif /* USE_SOFTLINKCHECK */
 753     }
 754
 755     return error;
 756 }
 757
 758
 759 static
 760 int CheckDir(BPTR lock, struct ExAllData *ead, ULONG eadSize,
 761              struct ExAllControl *eac, struct table *dirs,
 762              struct table *files, struct data *data)
 763 {
 764     int   error = RETURN_OK;
 765     BOOL  loop;
 766     struct ExAllData *oldEad = ead;
 767
 768     do
 769     {
 770         ead = oldEad;
 771         loop = ExAll(lock, ead, eadSize, ED_COMMENT, eac);
 772
 773         if(!loop && IoErr() != ERROR_NO_MORE_ENTRIES)
 774         {
 775             error = RETURN_ERROR;
 776             break;
 777         }
 778
 779         if(eac->eac_Entries != 0)
 780         {
 781             do
 782             {
 783
 784 #if USE_SOFTLINKCHECK
 785                 if (ead->ed_Type == ST_SOFTLINK)
 786                 {
 787                     BPTR dirlock, l;
 788
 789                     dirlock = CurrentDir(lock);
 790                     l = Lock(ead->ed_Name, ACCESS_READ);
 791                     CurrentDir(dirlock);
 792
 793                     if (l)
 794                     {
 795                         UBYTE _fib[sizeof(struct FileInfoBlock) + 3];
 796                         struct FileInfoBlock *fib = (APTR) (((IPTR) _fib + 3) & ~3);
 797
 798                         if (Examine(l, fib))
 799                         {
 800                             ead->ed_Type = fib->fib_DirEntryType;
 801                             //ead->ed_Size = fib->fib_Size;
 802                         }
 803
 804                         UnLock(l);
 805                     }
 806                 }
 807 #endif /* USE_SOFTLINKCHECK */
 808
 809                 if (!AddEntry(ead->ed_Type > 0 ? dirs : files,ead->ed_Name, data))
 810                 {
 811                     loop = 0;
 812                     error = RETURN_FAIL;
 813                     SetIoErr(ERROR_NO_FREE_STORE);
 814                     break;
 815                 }
 816
 817                 ead = ead->ed_Next;
 818             }
 819             while(ead != NULL);
 820         }
 821     }
 822     while((loop) && (error == RETURN_OK));
 823
 824     return error;
 825 }