workbench/c/Info.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Info Cli Command
   6     Lang: English
   7 */
   8
   9 /******************************************************************************
  10
  11
  12     NAME
  13
  14         Info
  15
  16     SYNOPSIS
  17
  18         DISKS/S, VOLS=VOLUMES/S, ALL/S, BLOCKS/S, DEVICES/M
  19
  20     LOCATION
  21
  22         C:
  23
  24     FUNCTION
  25
  26     Show information on file system devices and volumes. When given no
  27     arguments, information on all devices and volumes found in the system
  28     is displayed. If information is wanted only for some specific devices,
  29     these names may be given as arguments.
  30
  31     INPUTS
  32
  33     DISKS     --  show information on file system devices
  34     VOLS      --  show information on volumes
  35     ALL       --  show information on bad devices or volumes
  36     BLOCKS    --  show additional block size and usage information
  37     DEVICES   --  device names to show information about
  38
  39     RESULT
  40
  41     NOTES
  42
  43     EXAMPLE
  44
  45     Info
  46
  47     Unit                 Size    Used    Free Full Errs   State    Type Name
  48     Harddisk:        964.1M  776.7M  187.4M  81%    0 read/write  OFS AROS
  49     RAM:                 8.0M    7.1M    7.1M  12%    0 read/write  OFS Ram Disk
  50
  51     BUGS
  52
  53     SEE ALSO
  54
  55     INTERNALS
  56
  57     The original source showed that AROS version of ReadArgs() handles
  58     the /M switch with zero arguments differently from AmigaOS. While AROS
  59     returns an array where the first pointer is NULL, AmigaOS just returns
  60     NULL.
  61
  62     HISTORY
  63
  64     16.11.2000  SDuvan  --  converted to AROS
  65     23.12.2000  SDuvan  --  changed semantics and updated
  66                             (now fully functional)
  67     17.02.2005  Joe Fenton -- fixed 64bit calculation
  68
  69     Based on the original by:
  70     © 1997-1998 by Stephan Rupprecht
  71     All rights resevered
  72 ******************************************************************************/
  73
  74 #define  DEBUG 0
  75 #include <aros/debug.h>
  76
  77 #include <dos/dos.h>
  78 #include <dos/dosextens.h>
  79 #include <dos/filehandler.h>
  80 #include <exec/memory.h>
  81 #include <libraries/locale.h>
  82
  83 #include <proto/dos.h>
  84 #include <proto/exec.h>
  85 #include <proto/utility.h>
  86 #include <proto/locale.h>
  87 #include <proto/alib.h>
  88
  89 #include <string.h>
  90
  91 #define ID_MAC_DISK2       (0x4d414300L) /* MAC\0 - xfs mac disk */
  92 #define ID_MNX1_DISK       (0x4d4e5801L) /* MNX\1 - xfs minix disk */
  93 #define ID_MNX2_DISK       (0x4d4e5802L) /* MNX\2 - xfs minix disk */
  94 #define ID_QL5A_DISK       (0x514c3541L) /* QL5A - xfs ql 720k / ed disk */
  95 #define ID_QL5B_DISK       (0x514c3542L) /* QL5B - xfs ql 1440k disk */
  96 #define ID_ZXS0_DISK       (0x5a585300L) /* Spectrum Disciple - xfs */
  97 #define ID_ZXS1_DISK       (0x5a585301L) /* Spectrum UniDos - xfs */
  98 #define ID_ZXS2_DISK       (0x5a585302L) /* Spectrum SamDos - xfs */
  99 #define ID_ZXS4_DISK       (0x5a585304L) /* Spectrum Opus 180k - xfs */
 100 #define ID_ARME_DISK       (0x41524d44L) /* Archimedes - xfs */
 101 #define ID_ARMD_DISK       (0x41524d43L) /* Archimedes - xfs */
 102 #define ID_CPM_DISK        (0x43505c4dL) /* CP/M - xfs */
 103 #define ID_ZXS3_DISK       (0x5a585303L) /* ZXS\3 - Plus3Dos xfs */
 104 #define ID_1541_DISK       (0x31353431L) /* 1541 - xfs */
 105 #define ID_1581_DISK       (0x31353831L) /* 1581 - xfs */
 106 #define ID_MAC_DISK        (0x4d534800L) /* MSH\0 - CrossDos MACDisk ?! */
 107 #define ID_ACD0_DISK       (0x41434400L) /* ACD\0 - AmiCDFS disk */
 108 #define ID_CDFS_DISK       (0x43444653L) /* CDFS  - AmiCDFS disk */
 109 #define ID_CACHECDFS_DISK  (0x43443031L)
 110 #define ID_ASIMCDFS_DISK   (0x662dabacL)
 111 #define ID_PFS_DISK        (0x50465301L) /* PFS */
 112 #define ID_PFS2_DISK       (0x50465302L)
 113 #define ID_PFS2_SCSI_DISK  (0x50445300L)
 114 #define ID_PFS2_muFS_DISK  (0x6d755046L)
 115 #define ID_FLOPPY_PFS_DISK (0x50465300L)
 116 #define ID_P2A0_DISK       (0x50324130L)
 117 #define ID_AFS0_DISK       (0x41465300L) /* AFS\0 */
 118 #define ID_muFS_DISK       (0x6d754653L) /* muFS - Multiuserfsys */
 119 #define ID_FAT12_DISK      (0x46415400L) /* FAT12 */
 120 #define ID_FAT16_DISK      (0x46415401L) /* FAT16 */
 121 #define ID_FAT32_DISK      (0x46415402L) /* FAT32 */
 122 #define ID_EXT2_DISK       (0x45585432L) /* Extended 2 - Linux */
 123
 124
 125 /* Prototypes */
 126
 127 ULONG ComputeKBytes(ULONG a, ULONG b);
 128 void FmtProcedure(struct Hook *hook, char a, struct Locale *locale);
 129 ULONG ExtUDivMod32(ULONG a, ULONG b, ULONG *mod);
 130 void doInfo();
 131
 132
 133 const TEXT VersionStr[] = "$VER: Info 41.1 (16.11.2000)";
 134
 135 struct Catalog  *cat;
 136 struct Locale   *loc = NULL;
 137 ULONG            MaxLen;
 138
 139 APTR             Pool;
 140
 141
 142 /* catalog string id:s */
 143 enum
 144 {
 145     UNIT,
 146     DEVTITLE,
 147     DISKSTITLE,
 148     DEVFMTSTR,
 149     DATEFMTSTR,
 150     READONLY,
 151     READWRITE,
 152     VALIDATING,
 153     MOUNTEDSTR,
 154     SMALLNUMFMT,
 155     BIGNUMFMT,
 156     VOLNAMEFMTSTR,
 157     BLOCKSSTR
 158 };
 159
 160
 161 struct InfoDosNode
 162 {
 163     struct InfoDosNode *Next;
 164     ULONG               IsVolume;
 165     ULONG               DosType;
 166     struct MsgPort     *Task;
 167     struct DateStamp    VolumeDate;
 168     TEXT                Name[108];
 169 };
 170
 171 struct InfoDosNode *head = NULL;
 172
 173
 174 struct DiskTypeList
 175 {   ULONG   id;
 176     STRPTR  str;
 177 };
 178
 179 struct DiskTypeList dtl[] =
 180 {
 181     { ID_DOS_DISK,         "OFS" },
 182     { ID_FFS_DISK,         "FFS" },
 183     { ID_INTER_DOS_DISK,   "OFS-INT" },
 184     { ID_INTER_FFS_DISK,   "FFS-INT" },
 185     { ID_FASTDIR_DOS_DISK, "OFS-DC" },
 186     { ID_FASTDIR_FFS_DISK, "FFS-DC" },
 187     { ID_MSDOS_DISK,       "MS-DOS" },
 188     { ID_ACD0_DISK,        "CDFS" },
 189     { ID_CACHECDFS_DISK,   "CDFS" },
 190     { ID_ASIMCDFS_DISK,    "CDFS" },
 191     { ID_NOT_REALLY_DOS,   "NO DOS" },
 192     { ID_MAC_DISK2,        "MAC" },
 193     { ID_MNX1_DISK,        "Minix" },
 194     { ID_QL5A_DISK,        "QL720k" },
 195     { ID_QL5B_DISK,        "QL1.4M" },
 196     { ID_CPM_DISK,         "CP/M" },
 197     { ID_ZXS3_DISK,        "+3Dos" },
 198     { ID_ZXS0_DISK,        "Disciple " },
 199     { ID_ZXS1_DISK,        "UniDos" },
 200     { ID_ZXS2_DISK,        "SamDos" },
 201     { ID_ZXS4_DISK,        "Opus" },
 202     { ID_P2A0_DISK,        "NETWORK" },
 203     { ID_FAT12_DISK,       "FAT12" },
 204     { ID_FAT16_DISK,       "FAT16" },
 205     { ID_FAT32_DISK,       "FAT32" },
 206     { ID_SFS_BE_DISK,      "SFS" },
 207     { ID_SFS_LE_DISK,      "sfs" },
 208     { ID_PFS_DISK,         "PFS" },
 209     { ID_EXT2_DISK,        "EXT2" },
 210     { 0L, 0L }
 211 };
 212
 213
 214 /****************************************************************************/
 215
 216 int UtilityBase_version = 0;
 217 int LocaleBase_version = 0;
 218
 219 int __nocommandline;
 220
 221 int main(void)
 222 {
 223     static struct TagItem loctags[] = { { OC_Version, 1 },
 224                                                 { TAG_END   , 0 } };
 225     cat = OpenCatalogA(NULL, "info_com.catalog", loctags);
 226     loc = OpenLocale(NULL);
 227
 228     D(bug("Calling doInfo()\n"));
 229
 230     doInfo();
 231
 232     CloseLocale(loc);
 233     CloseCatalog(cat);
 234
 235     return RETURN_OK;           /* TODO: Fix this */
 236 }
 237
 238
 239 CONST_STRPTR GetStrFromCat(ULONG id, CONST_STRPTR def)
 240 {
 241     if(cat != NULL)
 242     {
 243         def = GetCatalogStr(cat, id, def);
 244     }
 245
 246     return def;
 247 }
 248
 249
 250 void VLPrintf(ULONG id, CONST_STRPTR def, const IPTR* argarray)
 251 {
 252     def = GetStrFromCat(id, def);
 253     VPrintf(def, (IPTR *)argarray);
 254 }
 255
 256
 257 BOOL myMatchPatternNoCase(STRPTR *array, STRPTR str)
 258 {
 259     if(*array != NULL)
 260     {
 261         while(*array != NULL)
 262         {
 263             UBYTE   matchstr[128];
 264             UBYTE   name[32];
 265             UBYTE  *p = *array++;
 266             UBYTE   len = strlen(p);
 267
 268             if(p[len - 1] != ':')
 269             {
 270                 CopyMem(p, name, len);
 271                 name[len] = ':';
 272                 name[len + 1] = 0;
 273                 p = name;
 274             }
 275
 276             if(ParsePatternNoCase(p, matchstr, sizeof(matchstr)) != -1)
 277             {
 278                 if(MatchPatternNoCase(matchstr, str))
 279                 {
 280                     return TRUE;
 281                 }
 282             }
 283         }
 284
 285         return FALSE;
 286     }
 287
 288     return TRUE;
 289 }
 290
 291
 292 BOOL ScanDosList(STRPTR *filter)
 293 {
 294     struct InfoDosNode *idn = 0L;
 295     struct DosList     *ndl, *dl;
 296     STRPTR             *strray = NULL, dummy = NULL;
 297     BOOL                err = FALSE;
 298
 299     D(bug("Entered ScanDosList()\n"));
 300
 301     if (filter == NULL) filter = &dummy;
 302
 303     if(*filter != NULL)
 304     {
 305         strray = AllocPooled(Pool, sizeof(STRPTR)*MAX_MULTIARGS);
 306
 307         if(strray != NULL)
 308         {
 309             STRPTR  *p = filter;
 310             LONG     i = 0;
 311
 312             while(*p)
 313                 strray[i++] = *p++;
 314
 315             while(i < MAX_MULTIARGS)
 316                 strray[i++] = NULL;
 317         }
 318         else
 319             return FALSE;
 320     }
 321
 322     /* lock list of devices & vols */
 323     dl = ndl = LockDosList(LDF_ASSIGNS | LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 324
 325     if(strray != NULL)
 326     {
 327         STRPTR *p = strray;
 328
 329         while(*p)
 330             p++;
 331
 332         while((ndl = NextDosEntry(ndl, LDF_ASSIGNS | LDF_VOLUMES | LDF_READ)) != NULL)
 333         {
 334             TEXT    name[108];
 335             STRPTR  taskName = NULL;  /* Initialized to avoid a warning */
 336
 337             __sprintf(name, "%b:", ndl->dol_Name);
 338
 339             if ((ndl->dol_Type > DLT_VOLUME) || !(myMatchPatternNoCase(strray, name)))
 340             {
 341                 continue;
 342             }
 343
 344             switch (ndl->dol_Type)
 345             {
 346             case DLT_VOLUME:
 347                 taskName =  ((struct Task *)ndl->dol_Task->mp_SigTask)->tc_Node.ln_Name;
 348
 349                 D(bug("Found volume %s\n", taskName));
 350                 break;
 351
 352             case DLT_DIRECTORY:
 353                 {
 354                     struct AssignList *al = ndl->dol_misc.dol_assign.dol_List;
 355
 356                     taskName = ((struct Task *)((struct FileLock *)BADDR(ndl->dol_Lock))->fl_Task->mp_SigTask)->tc_Node.ln_Name;
 357
 358                     D(bug("Found directory %s\n", taskName));
 359
 360                     while(al != NULL)
 361                     {
 362                         *p++ = ""; // TODO!!!  ((struct Task *)((struct FileLock *)BADDR(al->al_Lock))->fl_Task->mp_SigTask)->tc_Node.ln_Name;
 363                         al = al->al_Next;
 364                     }
 365                 }
 366                 break;
 367             }
 368
 369             *p++ = taskName;
 370         }
 371     }
 372     else
 373         strray = filter;
 374
 375     ndl = dl;
 376
 377     while((ndl = NextDosEntry(ndl, LDF_VOLUMES | LDF_DEVICES | LDF_READ)) != NULL)
 378     {
 379         UBYTE  len = 0;
 380         UBYTE  type = ndl->dol_Type;
 381         UBYTE  name[108];
 382
 383         /* do not start non-started handlers or open CON: or RAW: windows.. */
 384         if(type == DLT_DEVICE && !ndl->dol_Task)
 385             continue;
 386
 387         __sprintf(name, "%b:", ndl->dol_Name);
 388         D(bug("Found name %s\n", name));
 389
 390         if((type == DLT_DEVICE) && (myMatchPatternNoCase(strray, name) == FALSE))
 391         {
 392             int i;
 393
 394             D(bug("Failure! -- name = %s, strray = %p\n", name, (void *)strray));
 395
 396             for (i = 0; strray[i] != NULL; i++)
 397             {
 398                 D(bug("Strray %i = %s\n", i, strray[i]));
 399             }
 400
 401             continue;
 402         }
 403
 404         idn = (struct InfoDosNode *)AllocPooled(Pool, sizeof(struct InfoDosNode));
 405
 406         if(idn == NULL)
 407         {
 408             err = TRUE;
 409             break;
 410         }
 411
 412         idn->Task     = ndl->dol_Task;
 413         idn->IsVolume = type == DLT_VOLUME;
 414
 415         while((idn->Name[len] = name[len]))
 416             len++;
 417
 418         if(type == DLT_VOLUME)
 419         {
 420             idn->VolumeDate = ((struct DeviceList *)ndl)->dl_VolumeDate;
 421             idn->Name[len - 1] = '\0';       /* remove ':' */
 422         }
 423         else
 424         {
 425             BPTR ptr = ndl->dol_misc.dol_handler.dol_Startup;
 426             struct FileSysStartupMsg *fssm = (struct FileSysStartupMsg *)BADDR(ptr);
 427
 428             idn->DosType = ID_DOS_DISK;
 429
 430             //  DLT_DEVICE
 431             if (len > MaxLen)
 432                 MaxLen = len;
 433
 434             if (fssm)
 435             {
 436                 struct DosEnvec *de;
 437                 de = (struct DosEnvec *)BADDR(fssm->fssm_Environ);
 438
 439                 if (de && (de->de_TableSize & 0xffffff00) == 0)
 440                     if (de->de_DosType)
 441                         idn->DosType = de->de_DosType;
 442             }
 443         }
 444
 445         /* kinda insert sort */
 446         {
 447             struct InfoDosNode *work = head;
 448             struct InfoDosNode *prev = NULL;
 449
 450             while((work != NULL) && (Stricmp(idn->Name, work->Name) > 0))
 451             {
 452                 prev = work;
 453                 work = work->Next;
 454             }
 455
 456             if(prev != NULL)
 457                 prev->Next = idn;
 458             else
 459                 head = idn;
 460
 461             idn->Next = work;
 462         }
 463     }
 464
 465     /* unlock list of devices and volumes */
 466     UnLockDosList(LDF_ASSIGNS | LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 467
 468     // strray freed at DeletePool
 469
 470     return !err;
 471 }
 472
 473
 474 void PrintNum(ULONG num)
 475 {
 476     /* MBytes ? */
 477     if(num > 1023)
 478     {
 479         ULONG  x, xx;
 480         char   fmt = 'M';
 481
 482         /* GBytes ? */
 483         if(num > 0xfffff)
 484         {
 485             num >>= 10;
 486             fmt = 'G';
 487         }
 488
 489         num = ExtUDivMod32(UMult32(num, 100) >> 10, 100, &x);
 490
 491         /* round */
 492         x = ExtUDivMod32(x, 10, &xx);
 493
 494         if(xx > 4)
 495         {
 496             if(++x > 9)
 497             {
 498                 x = 0;
 499                 num++;
 500             }
 501         }
 502
 503         IPTR args[] = {num, x, fmt};
 504         VLPrintf(BIGNUMFMT, "%5ld.%ld%lc", args);
 505     }
 506     else
 507     {
 508         IPTR args[] = { num };
 509         VLPrintf(SMALLNUMFMT, "%7ldK", args);
 510     }
 511 }
 512
 513
 514 STRPTR GetFSysStr(ULONG DiskType)
 515 {
 516     struct DiskTypeList *dtlptr = dtl;
 517
 518     STRPTR ptr = NULL;
 519
 520     do {
 521         if(dtlptr->id == DiskType)
 522         {
 523             ptr = dtlptr->str;
 524             break;
 525         }
 526     } while(*((ULONG *)dtlptr++));
 527
 528     if(ptr == NULL)
 529     {
 530         static TEXT buffer[5];
 531
 532         ptr = (STRPTR)buffer;
 533         *((ULONG *)ptr) = AROS_LONG2BE(DiskType);
 534
 535         if(ptr[3] < ' ')
 536             ptr[3] += '0';
 537
 538         ptr[4] = '\0';
 539     }
 540
 541     return ptr;
 542 }
 543
 544
 545 enum
 546 {
 547     ARG_DISKS,
 548     ARG_VOLS,
 549     ARG_ALL,
 550     ARG_BLOCKS,
 551     ARG_DEVS,
 552     NOOFARGS
 553 };
 554
 555
 556 void doInfo()
 557 {
 558     struct RDArgs       *rdargs;
 559     struct Process      *proc;
 560     struct Window       *win;
 561     struct InfoDosNode  *idn;
 562
 563     struct InfoData *id = AllocVec(sizeof(struct InfoData), MEMF_ANY);
 564
 565     IPTR   args[] = { (IPTR)FALSE,
 566                       (IPTR)FALSE,
 567                       (IPTR)FALSE,
 568                       (IPTR)FALSE,
 569                       (IPTR)NULL };
 570
 571     CONST_STRPTR unit = GetStrFromCat(UNIT, "Unit");
 572
 573     if(id == NULL)
 574     {
 575         PrintFault(ERROR_NO_FREE_STORE, NULL);
 576         return;
 577     }
 578
 579     Pool = CreatePool(MEMF_ANY, 1024, 1024);
 580
 581     if(Pool == NULL)
 582     {
 583         PrintFault(ERROR_NO_FREE_STORE, NULL);
 584         return;                 /* ??? */
 585     }
 586
 587     D(bug("Calling ReadArgs()\n"));
 588
 589     /* read arguments */
 590     rdargs = ReadArgs("DISKS/S,VOLS=VOLUMES/S,ALL/S,BLOCKS/S,DEVICES/M",
 591                       args, NULL);
 592
 593     if(rdargs != NULL)
 594     {
 595         BOOL     disks    = (BOOL)args[ARG_DISKS];
 596         BOOL     vols     = (BOOL)args[ARG_VOLS];
 597         BOOL     showall  = (BOOL)args[ARG_ALL];
 598         BOOL     blocks   = (BOOL)args[ARG_BLOCKS];
 599         STRPTR  *devs     = (STRPTR *)args[ARG_DEVS];
 600
 601         if (devs && (*devs == NULL)) devs = NULL;
 602
 603         /* If nothing is specified, show everything we got */
 604         if(devs == NULL && !disks && !vols)
 605         {
 606             vols = TRUE;
 607             disks = TRUE;
 608         }
 609
 610         /* check pattern strings */
 611
 612         if(devs != NULL)
 613         {
 614             STRPTR  *p = devs;
 615
 616             while(*p != NULL)
 617             {
 618                 TEXT  matchstr[128];
 619
 620                 if(ParsePatternNoCase(*p, matchstr, sizeof(matchstr)) == -1)
 621                 {
 622                     PrintFault(IoErr(), *p);
 623                     goto end;
 624                 }
 625
 626                 p++;
 627             }
 628         }
 629
 630         /* avoid requesters */
 631         proc = (struct Process *)FindTask(NULL);
 632         win  = (struct Window *)proc->pr_WindowPtr;
 633         proc->pr_WindowPtr = (struct Window *)~0;
 634
 635         MaxLen = strlen(unit);
 636
 637         D(bug("Calling ScanDosList()\n"));
 638
 639         /* scan doslist */
 640         if(ScanDosList(devs))
 641         {
 642             CONST_STRPTR  dstate[3] = { GetStrFromCat(READONLY,   "read only"),
 643                                   GetStrFromCat(VALIDATING, "validating"),
 644                                   GetStrFromCat(READWRITE,  "read/write") };
 645             STRPTR  datetimeFmt = NULL;
 646             BOOL    first = TRUE;
 647             TEXT    nfmtstr[16];
 648             TEXT    buf[64];
 649
 650             D(bug("Printing stuff\n"));
 651
 652             /* get datetimefmt string */
 653             if(loc && (GetVar("info_datetime", buf, sizeof(buf), 0L) > 0L))
 654             {
 655                 datetimeFmt = buf;
 656             }
 657
 658             /* calc format string for 'Unit' */
 659             __sprintf(nfmtstr, "%%-%lds", MaxLen);
 660
 661             /* show device infomation */
 662             if(devs != NULL || disks || !vols)
 663             {
 664                 for(idn = head; idn; idn = idn->Next)
 665                 {
 666                     BPTR    lock;
 667                     STRPTR  name = idn->Name;
 668
 669                     D(bug("Got name = %s\n", name));
 670
 671                     if(!idn->IsVolume && IsFileSystem(name))
 672                     {
 673                         BOOL gotinfo = FALSE;
 674                         /* if first device to print, print title */
 675                         if(first || blocks)
 676                         {
 677                             if(!first)
 678                                 Printf("\n");
 679
 680                             D(bug("Printing device\n"));
 681
 682                             VLPrintf(~0, nfmtstr, (IPTR*) &unit);
 683                             VLPrintf(DEVTITLE, "    Size    Used    Free Full Errs   State    Type    Name\n", NULL);
 684
 685                             first = FALSE;
 686                         }
 687
 688                         VLPrintf(~0, nfmtstr, (IPTR*) &name);
 689
 690                         D(bug("Locking \"%s\"\n", name));
 691                         lock = Lock(name, SHARED_LOCK);
 692
 693                         D(bug("Lock = %p\n", (APTR)lock));
 694
 695                         if(lock != BNULL)
 696                         {
 697                             D(bug("Got lock on %s\n", name));
 698
 699                             if(Info(lock, id) == DOSTRUE)
 700                             {
 701                                 D(bug("Calling NameFromLock()\n"));
 702
 703                                 if(NameFromLock(lock, name, 108L))
 704                                 {
 705                                     LONG len = strlen(name) - 1;
 706
 707                                     if(name[len] == ':')
 708                                     {
 709                                         name[len] = '\0';
 710                                     }
 711                                 }
 712
 713                                 gotinfo = TRUE;
 714                             }
 715                             UnLock(lock);
 716
 717                         } else if (idn->Task) {
 718                             name = NULL;
 719                             D(bug("Calling ACTION_DISK_INFO\n"));
 720                             if (DoPkt(idn->Task, ACTION_DISK_INFO, (SIPTR)MKBADDR(id), (SIPTR)BNULL, (SIPTR)BNULL, (SIPTR)BNULL, (SIPTR)BNULL)) {
 721                                 gotinfo = TRUE;
 722                             }
 723                         }
 724
 725                         if (gotinfo) {
 726                             ULONG  x, y;
 727
 728                             D(bug("Got info on %s\n", name));
 729
 730                             if (id->id_DiskType == ID_NO_DISK_PRESENT) {
 731                                 VLPrintf(~0, " No disk present\n", NULL);
 732                             } else if (id->id_DiskType == ID_NOT_REALLY_DOS) {
 733                                 VLPrintf(~0, " Not a DOS disk\n", NULL);
 734                             } else if (id->id_DiskType == ID_UNREADABLE_DISK) {
 735                                 VLPrintf(~0, " Unreadable disk\n", NULL);
 736                             } else {
 737                                 x = ComputeKBytes(id->id_NumBlocks, id->id_BytesPerBlock);
 738                                 y = ComputeKBytes(id->id_NumBlocksUsed, id->id_BytesPerBlock);
 739
 740                                 PrintNum(x);
 741                                 PrintNum(y);
 742                                 PrintNum(x - y);
 743
 744                                 if(x > 0xfffff)
 745                                 {
 746                                     x >>= 10;
 747                                     y >>= 10;
 748                                 }
 749
 750                                 if(x)
 751                                 {
 752                                     x = ExtUDivMod32(UDivMod32(UMult32(y, 1000), x), 10, &y);
 753
 754                                     if(y > 4)
 755                                         x++;
 756                                 }
 757                                 else
 758                                     x = 0;
 759
 760                                 // y = ((struct DeviceList *)BADDR(id->id_VolumeNode))->dl_DiskType;
 761
 762                                 //                              if(!y)
 763                                     y = id->id_DiskType;
 764
 765                                 if((idn->DosType & ID_DOS_DISK) != ID_DOS_DISK)
 766                                     y = idn->DosType;
 767
 768                                 {
 769                                     IPTR args[] = {
 770                                     x,
 771                                     id->id_NumSoftErrors,
 772                                     ((id->id_DiskState >= ID_WRITE_PROTECTED) && (id->id_DiskState <= ID_VALIDATED)) ?
 773                                     (IPTR) dstate[id->id_DiskState - ID_WRITE_PROTECTED] : (IPTR) "",
 774                                     (IPTR) GetFSysStr(y),
 775                                     (IPTR) name};
 776                                      VLPrintf(DEVFMTSTR, "%4ld%% %4ld %-11s%-8s%s\n", args);
 777                                 }
 778
 779                                 if(blocks)
 780                                 {
 781                                     IPTR args[] = {
 782                                         id->id_NumBlocks,
 783                                         id->id_NumBlocksUsed,
 784                                         id->id_NumBlocks-id->id_NumBlocksUsed,
 785                                         id->id_BytesPerBlock};
 786                                     VLPrintf(BLOCKSSTR,
 787                                             "\nTotal blocks: %-10ld  Blocks used: %ld\n"
 788                                             " Blocks free: %-10ld    Blocksize: %ld\n",
 789                                             args);
 790                                 }
 791                             }
 792                         }
 793                         else
 794                         {
 795                             D(bug("Info failure\n"));
 796                             VLPrintf(~0, "\n", NULL);
 797                         }
 798
 799                         {
 800                             LONG err = IoErr();
 801
 802                             /* just ignore PIPEFS */
 803                             if (err == ERROR_ACTION_NOT_KNOWN)
 804                                 if (strcmp(name, "PIPEFS:") == 0)
 805                                     err = 0;
 806
 807                             if (err && showall)
 808                             {
 809                                 VLPrintf(~0, nfmtstr, (IPTR*) &name);
 810                                 PrintFault(err, NULL);
 811                             }
 812                         }
 813                     }
 814                 }
 815             }
 816
 817             /* show volumes */
 818             if(vols || (!devs && !disks))
 819             {
 820                 if(!first)
 821                     PutStr("\n");
 822
 823                 VLPrintf(DISKSTITLE, "Volumes\n", NULL);
 824
 825                 for(MaxLen = 15, idn = head; idn; idn = idn->Next)
 826                 {
 827                     if(idn->IsVolume)
 828                     {
 829                         LONG len = strlen(idn->Name);
 830
 831                         if(len > MaxLen)
 832                             MaxLen = len;
 833                     }
 834                 }
 835
 836                 __sprintf(nfmtstr, "%%-%lds%%-10s", MaxLen+1);
 837
 838                 for(idn = head; idn; idn = idn->Next)
 839                 {
 840                     if(idn->IsVolume)
 841                     {
 842                         IPTR args[] = {
 843                             (IPTR) idn->Name,
 844                             (IPTR) GetStrFromCat(MOUNTEDSTR, "[Mounted]")};
 845                             // idn->Task ? GetStrFromCat(MOUNTEDSTR, "[Mounted]") : ""); TODO
 846                         VLPrintf(VOLNAMEFMTSTR, nfmtstr, args);
 847
 848                         if(datetimeFmt)
 849                         {
 850                             UBYTE datestr[128];
 851                             static struct Hook hook;
 852
 853                             memset(&hook, 0, sizeof(struct Hook));
 854
 855                             hook.h_SubEntry = (HOOKFUNC)FmtProcedure;
 856                             hook.h_Data = datestr;
 857
 858                             FormatDate(loc, datetimeFmt, &idn->VolumeDate, &hook);
 859
 860                             PutStr(datestr);
 861                         }
 862                         else
 863                         {
 864                             TEXT  StrDay[LEN_DATSTRING];
 865                             TEXT  StrDate[LEN_DATSTRING];
 866                             TEXT  StrTime[LEN_DATSTRING];
 867
 868                             struct DateTime dt;
 869
 870                             dt.dat_Flags   = DTF_SUBST;
 871                             dt.dat_Format  = FORMAT_DOS;
 872                             dt.dat_StrDay  = StrDay;
 873                             dt.dat_StrDate = StrDate;
 874                             dt.dat_StrTime = StrTime;
 875                             dt.dat_Stamp   = idn->VolumeDate;
 876
 877                             if(DateToStr(&dt))
 878                             {
 879                                 if(Strnicmp(StrDate, StrDay, strlen(StrDay)) == 0)
 880                                 {
 881                                     dt.dat_Flags = 0L;
 882                                     DateToStr(&dt);
 883                                 }
 884
 885                                 IPTR args[] = {(IPTR) StrDay, (IPTR) StrDate, (IPTR) StrTime};
 886                                 VLPrintf(DATEFMTSTR, "created %.3s, %-10s %s", args);
 887                             }
 888                         }
 889
 890                         PutStr("\n");
 891                     }
 892                 }
 893             }
 894         }
 895         else
 896         {
 897             PrintFault( ERROR_NO_FREE_STORE, NULL);
 898         }
 899
 900         /* reset window pointer of our process */
 901         proc->pr_WindowPtr = win;
 902
 903         /* free args */
 904         FreeArgs(rdargs);
 905     }
 906
 907
 908  end: /* free allocated memory */
 909     FreeVec(id);
 910     DeletePool(Pool);
 911 }
 912
 913
 914 ULONG ComputeKBytes(ULONG a, ULONG b)
 915 {
 916     // UQUAD result = UMult64(a, b);
 917
 918     UQUAD result = (UQUAD)a * b;
 919
 920     return (ULONG)(result >> 10);
 921 }
 922
 923
 924 void FmtProcedure(struct Hook *hook, char a, struct Locale *locale)
 925 {
 926     *((STRPTR)hook->h_Data) = a;
 927     hook->h_Data = (STRPTR) hook->h_Data + 1;
 928 }
 929
 930
 931 ULONG ExtUDivMod32(ULONG a, ULONG b, ULONG *mod)
 932 {
 933     *mod = a % b;
 934
 935     return a/b;
 936 }