workbench/c/Dir.c

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