workbench/c/Info.c

   1 /*
   2     Copyright © 1995-2007, 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         Sys: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_PFS2_DISK       (0x50465302L)
 112 #define ID_PFS2_SCSI_DISK  (0x50445300L)
 113 #define ID_PFS2_muFS_DISK  (0x6d755046L)
 114 #define ID_FLOPPY_PFS_DISK (0x50465300L)
 115 #define ID_P2A0_DISK       (0x50324130L)
 116 #define ID_AFS0_DISK       (0x41465300L) /* AFS\0 */
 117 #define ID_muFS_DISK       (0x6d754653L) /* muFS - Mulituserfsys */
 118 #define ID_FAT12_DISK      (0x46415400L) /* FAT12 */
 119 #define ID_FAT16_DISK      (0x46415401L) /* FAT16 */
 120 #define ID_FAT32_DISK      (0x46415402L) /* FAT32 */
 121
 122
 123 /* Prototypes */
 124
 125 ULONG ComputeKBytes(ULONG a, ULONG b);
 126 void FmtProcedure(struct Hook *hook, char a, struct Locale *locale);
 127 ULONG ExtUDivMod32(ULONG a, ULONG b, ULONG *mod);
 128 void doInfo();
 129
 130
 131 const TEXT VersionStr[] = "$VER: Info 41.1 (16.11.2000)";
 132
 133 struct Catalog  *cat;
 134 struct Locale   *loc = NULL;
 135 ULONG            MaxLen;
 136
 137 APTR             Pool;
 138
 139
 140 /* catalog string id:s */
 141 enum
 142 {
 143     UNIT,
 144     DEVTITLE,
 145     DISKSTITLE,
 146     DEVFMTSTR,
 147     DATEFMTSTR,
 148     READONLY,
 149     READWRITE,
 150     VALIDATING,
 151     MOUNTEDSTR,
 152     SMALLNUMFMT,
 153     BIGNUMFMT,
 154     VOLNAMEFMTSTR,
 155     BLOCKSSTR
 156 };
 157
 158
 159 struct InfoDosNode
 160 {
 161     struct InfoDosNode *Next;
 162     ULONG               IsVolume;
 163     ULONG               DosType;
 164     struct MsgPort     *Task;
 165     struct DateStamp    VolumeDate;
 166     TEXT                Name[108];
 167 };
 168
 169 struct InfoDosNode *head = NULL;
 170
 171
 172 struct DiskTypeList
 173 {   ULONG   id;
 174     STRPTR  str;
 175 };
 176
 177 struct DiskTypeList dtl[] =
 178 {
 179     { ID_DOS_DISK,         "OFS" },
 180     { ID_FFS_DISK,         "FFS" },
 181     { ID_INTER_DOS_DISK,   "OFS-INT" },
 182     { ID_INTER_FFS_DISK,   "FFS-INT" },
 183     { ID_FASTDIR_DOS_DISK, "OFS-DC" },
 184     { ID_FASTDIR_FFS_DISK, "FFS-DC" },
 185     { ID_MSDOS_DISK,       "MS-DOS" },
 186     { ID_ACD0_DISK,        "CDFS" },
 187     { ID_CACHECDFS_DISK,   "CDFS" },
 188     { ID_ASIMCDFS_DISK,    "CDFS" },
 189     { ID_NOT_REALLY_DOS,   "NO DOS" },
 190     { ID_MAC_DISK2,        "MAC" },
 191     { ID_MNX1_DISK,        "Minix" },
 192     { ID_QL5A_DISK,        "QL720k" },
 193     { ID_QL5B_DISK,        "QL1.4M" },
 194     { ID_CPM_DISK,         "CP/M" },
 195     { ID_ZXS3_DISK,        "+3Dos" },
 196     { ID_ZXS0_DISK,        "Disciple " },
 197     { ID_ZXS1_DISK,        "UniDos" },
 198     { ID_ZXS2_DISK,        "SamDos" },
 199     { ID_ZXS4_DISK,        "Opus" },
 200     { ID_P2A0_DISK,        "NETWORK" },
 201     { ID_FAT12_DISK,       "FAT12" },
 202     { ID_FAT16_DISK,       "FAT16" },
 203     { ID_FAT32_DISK,       "FAT32" },
 204     { ID_FAT32_DISK,       "FAT32" },
 205     { ID_SFS_BE_DISK,      "SFS" },
 206     { ID_SFS_LE_DISK,      "sfs" },
 207     { 0L, 0L }
 208 };
 209
 210
 211 /****************************************************************************/
 212
 213 int UtilityBase_version = 0;
 214 int LocaleBase_version = 0;
 215
 216 int __nocommandline;
 217
 218 int main(void)
 219 {
 220     static struct TagItem loctags[] = { { OC_Version, 1 },
 221                                                 { TAG_END   , 0 } };
 222     cat = OpenCatalogA(NULL, "info_com.catalog", loctags);
 223     loc = OpenLocale(NULL);
 224
 225     D(bug("Calling doInfo()\n"));
 226
 227     doInfo();
 228
 229     CloseLocale(loc);
 230     CloseCatalog(cat);
 231
 232     return RETURN_OK;           /* TODO: Fix this */
 233 }
 234
 235
 236 CONST_STRPTR GetStrFromCat(ULONG id, CONST_STRPTR def)
 237 {
 238     if(cat != NULL)
 239     {
 240         def = GetCatalogStr(cat, id, def);
 241     }
 242
 243     return def;
 244 }
 245
 246
 247 void LPrintf(ULONG id, CONST_STRPTR def, ...) __stackparm;
 248
 249 void LPrintf(ULONG id, CONST_STRPTR def, ...)
 250 {
 251     def = GetStrFromCat(id, def);
 252
 253     VPrintf(def, ((IPTR *)(&def))+1);
 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, "%s:", ndl->dol_Ext.dol_AROS.dol_DevName);
 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 =  ndl->dol_Ext.dol_AROS.dol_DevName;   // ((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
 357                     taskName = ndl->dol_Ext.dol_AROS.dol_DevName; // ((struct Task *)((struct FileLock *)BADDR(ndl->dol_Lock))->fl_Task->mp_SigTask)->tc_Node.ln_Name;
 358
 359                     D(bug("Found directory %s\n", taskName));
 360
 361                     while(al != NULL)
 362                     {
 363                         *p++ = ""; // TODO!!!  ((struct Task *)((struct FileLock *)BADDR(al->al_Lock))->fl_Task->mp_SigTask)->tc_Node.ln_Name;
 364                         al = al->al_Next;
 365                     }
 366                 }
 367                 break;
 368             }
 369
 370             *p++ = taskName;
 371         }
 372     }
 373     else
 374         strray = filter;
 375
 376     ndl = dl;
 377
 378     while((ndl = NextDosEntry(ndl, LDF_VOLUMES | LDF_DEVICES | LDF_READ)) != NULL)
 379     {
 380         UBYTE  len = 0;
 381         UBYTE  type = ndl->dol_Type;
 382         UBYTE  name[108];
 383
 384         //      if(((type == DLT_DEVICE))) //  && (!ndl->dol_Task) TODO Check this!
 385         //          continue;
 386
 387         __sprintf(name, "%s:", ndl->dol_Ext.dol_AROS.dol_DevName);
 388
 389         D(bug("Found name %s\n", ndl->dol_Ext.dol_AROS.dol_DevName));
 390
 391         if((type == DLT_DEVICE) && (myMatchPatternNoCase(strray, name) == FALSE))
 392         {
 393             int i;
 394
 395             D(bug("Failure! -- name = %s, strray = %p\n", name, (void *)strray));
 396
 397             for (i = 0; strray[i] != NULL; i++)
 398             {
 399                 D(bug("Strray %i = %s\n", i, strray[i]));
 400             }
 401
 402             continue;
 403         }
 404
 405         idn = (struct InfoDosNode *)AllocPooled(Pool, sizeof(struct InfoDosNode));
 406
 407         if(idn == NULL)
 408         {
 409             err = TRUE;
 410             break;
 411         }
 412
 413         //      idn->Task     = (struct MsgPort *)ndl->dol_Task;
 414         idn->IsVolume = type == DLT_VOLUME;
 415
 416         while((idn->Name[len] = name[len]))
 417             len++;
 418
 419         if(type == DLT_VOLUME)
 420         {
 421             idn->VolumeDate = ((struct DeviceList *)ndl)->dl_VolumeDate;
 422             idn->Name[len - 1] = '\0';       /* remove ':' */
 423         }
 424         else
 425         {
 426             BPTR ptr = BADDR(ndl->dol_misc.dol_handler.dol_Startup);
 427             struct FileSysStartupMsg *fssm = (struct FileSysStartupMsg *)ptr;
 428
 429             idn->DosType = ID_DOS_DISK;
 430
 431             //  DLT_DEVICE
 432             if (len > MaxLen)
 433                 MaxLen = len;
 434
 435             if (fssm)
 436             {
 437                 struct DosEnvec *de;
 438                 de = (struct DosEnvec *)BADDR(fssm->fssm_Environ);
 439
 440                 if (de && (de->de_TableSize & 0xffffff00) == 0)
 441                     if (de->de_DosType)
 442                         idn->DosType = de->de_DosType;
 443             }
 444         }
 445
 446         /* kinda insert sort */
 447         {
 448             struct InfoDosNode *work = head;
 449             struct InfoDosNode *prev = NULL;
 450
 451             while((work != NULL) && (Stricmp(idn->Name, work->Name) > 0))
 452             {
 453                 prev = work;
 454                 work = work->Next;
 455             }
 456
 457             if(prev != NULL)
 458                 prev->Next = idn;
 459             else
 460                 head = idn;
 461
 462             idn->Next = work;
 463         }
 464     }
 465
 466     /* unlock list of devices and volumes */
 467     UnLockDosList(LDF_ASSIGNS | LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 468
 469     // strray freed at DeletePool
 470
 471     return !err;
 472 }
 473
 474
 475 void PrintNum(ULONG num)
 476 {
 477     /* MBytes ? */
 478     if(num > 1023)
 479     {
 480         ULONG  x, xx;
 481         char   fmt = 'M';
 482
 483         /* GBytes ? */
 484         if(num > 0xfffff)
 485         {
 486             num >>= 10;
 487             fmt = 'G';
 488         }
 489
 490         num = ExtUDivMod32(UMult32(num, 100) >> 10, 100, &x);
 491
 492         /* round */
 493         x = ExtUDivMod32(x, 10, &xx);
 494
 495         if(xx > 4)
 496         {
 497             if(++x > 9)
 498             {
 499                 x = 0;
 500                 num++;
 501             }
 502         }
 503
 504         LPrintf(BIGNUMFMT, "%5ld.%ld%lc", num, x, fmt);
 505     }
 506     else
 507     {
 508         LPrintf(SMALLNUMFMT, "%7ldK", num);
 509     }
 510 }
 511
 512
 513 STRPTR GetFSysStr(ULONG DiskType)
 514 {
 515     struct DiskTypeList *dtlptr = dtl;
 516
 517     STRPTR ptr = NULL;
 518
 519     do {
 520         if(dtlptr->id == DiskType)
 521         {
 522             ptr = dtlptr->str;
 523             break;
 524         }
 525     } while(*((ULONG *)dtlptr++));
 526
 527     if(ptr == NULL)
 528     {
 529         static TEXT buffer[5];
 530
 531         ptr = (STRPTR)buffer;
 532         *((ULONG *)ptr) = DiskType;
 533
 534         if(ptr[3] < ' ')
 535             ptr[3] += '0';
 536
 537         ptr[4] = '\0';
 538     }
 539
 540     return ptr;
 541 }
 542
 543
 544 enum
 545 {
 546     ARG_DISKS,
 547     ARG_VOLS,
 548     ARG_ALL,
 549     ARG_BLOCKS,
 550     ARG_DEVS,
 551     NOOFARGS
 552 };
 553
 554
 555 void doInfo()
 556 {
 557     struct RDArgs       *rdargs;
 558     struct Process      *proc;
 559     struct Window       *win;
 560     struct InfoDosNode  *idn;
 561
 562     static struct InfoData id;
 563
 564     IPTR   args[] = { (IPTR)FALSE,
 565                       (IPTR)FALSE,
 566                       (IPTR)FALSE,
 567                       (IPTR)FALSE,
 568                       (IPTR)NULL };
 569
 570     CONST_STRPTR unit = GetStrFromCat(UNIT, "Unit");
 571
 572     Pool = CreatePool(MEMF_ANY, 1024, 1024);
 573
 574     if(Pool == NULL)
 575     {
 576         PrintFault(ERROR_NO_FREE_STORE, NULL);
 577         return;                 /* ??? */
 578     }
 579
 580     D(bug("Calling ReadArgs()\n"));
 581
 582     /* read arguments */
 583     rdargs = ReadArgs("DISKS/S,VOLS=VOLUMES/S,ALL/S,BLOCKS/S,DEVICES/M",
 584                       args, NULL);
 585
 586     if(rdargs != NULL)
 587     {
 588         BOOL     disks    = (BOOL)args[ARG_DISKS];
 589         BOOL     vols     = (BOOL)args[ARG_VOLS];
 590         BOOL     showall  = (BOOL)args[ARG_ALL];
 591         BOOL     blocks   = (BOOL)args[ARG_BLOCKS];
 592         STRPTR  *devs     = (STRPTR *)args[ARG_DEVS];
 593
 594         if (devs && (*devs == NULL)) devs = NULL;
 595
 596         /* If nothing is specified, show everything we got */
 597         if(devs == NULL && !disks && !vols)
 598         {
 599             vols = TRUE;
 600             disks = TRUE;
 601         }
 602
 603         /* check pattern strings */
 604
 605         if(devs != NULL)
 606         {
 607             STRPTR  *p = devs;
 608
 609             while(*p != NULL)
 610             {
 611                 TEXT  matchstr[128];
 612
 613                 if(ParsePatternNoCase(*p, matchstr, sizeof(matchstr)) == -1)
 614                 {
 615                     PrintFault(IoErr(), *p);
 616                     goto end;
 617                 }
 618
 619                 p++;
 620             }
 621         }
 622
 623         /* avoid requesters */
 624         proc = (struct Process *)FindTask(NULL);
 625         win  = (struct Window *)proc->pr_WindowPtr;
 626         proc->pr_WindowPtr = (struct Window *)~0;
 627
 628         MaxLen = strlen(unit);
 629
 630         D(bug("Calling ScanDosList()\n"));
 631
 632         /* scan doslist */
 633         if(ScanDosList(devs))
 634         {
 635             CONST_STRPTR  dstate[3] = { GetStrFromCat(READONLY,   "read only"),
 636                                   GetStrFromCat(VALIDATING, "validating"),
 637                                   GetStrFromCat(READWRITE,  "read/write") };
 638             STRPTR  datetimeFmt = NULL;
 639             BOOL    first = TRUE;
 640             TEXT    nfmtstr[16];
 641             TEXT    buf[64];
 642
 643             D(bug("Printing stuff\n"));
 644
 645             /* get datetimefmt string */
 646             if(loc && (GetVar("info_datetime", buf, sizeof(buf), 0L) > 0L))
 647             {
 648                 datetimeFmt = buf;
 649             }
 650
 651             /* calc format string for 'Unit' */
 652             __sprintf(nfmtstr, "%%-%lds", MaxLen);
 653
 654             /* show device infomation */
 655             if(devs != NULL || disks || !vols)
 656             {
 657                 for(idn = head; idn; idn = idn->Next)
 658                 {
 659                     BPTR    lock;
 660                     STRPTR  name = idn->Name;
 661
 662                     D(bug("Got name = %s\n", name));
 663
 664                     if(!idn->IsVolume && IsFileSystem(name))
 665                     {
 666                         /* if first device to print, print title */
 667                         if(first || blocks)
 668                         {
 669                             if(!first)
 670                                 Printf("\n");
 671
 672                             D(bug("Printing device\n"));
 673
 674                             LPrintf(~0, nfmtstr, unit);
 675                             LPrintf(DEVTITLE, "    Size    Used    Free Full Errs   State    Type    Name\n");
 676
 677                             first = FALSE;
 678                         }
 679
 680                         D(bug("Locking \"%s\"\n", name));
 681                         lock = Lock(name, SHARED_LOCK);
 682
 683                         D(bug("Lock = %p\n", lock));
 684
 685                         if(lock != NULL)
 686                         {
 687                             D(bug("Got lock on %s\n", name));
 688
 689                             if(Info(lock, &id) == DOSTRUE)
 690                             {
 691                                 ULONG  x, y;
 692
 693                                 D(bug("Got info on %s\n", name));
 694
 695                                 LPrintf(~0, nfmtstr, name);
 696
 697                                 x = ComputeKBytes(id.id_NumBlocks, id.id_BytesPerBlock);
 698                                 y = ComputeKBytes(id.id_NumBlocksUsed, id.id_BytesPerBlock);
 699
 700                                 PrintNum(x);
 701                                 PrintNum(y);
 702                                 PrintNum(x - y);
 703
 704                                 D(bug("Calling NameFromLock()\n"));
 705
 706                                 if(NameFromLock(lock, name, 108L))
 707                                 {
 708                                     LONG len = strlen(name) - 1;
 709
 710                                     if(name[len] == ':')
 711                                     {
 712                                         name[len] = '\0';
 713                                     }
 714                                 }
 715
 716                                 if(x > 0xfffff)
 717                                 {
 718                                     x >>= 10;
 719                                     y >>= 10;
 720                                 }
 721
 722                                 if(x)
 723                                 {
 724                                     x = ExtUDivMod32(UDivMod32(UMult32(y, 1000), x), 10, &y);
 725
 726                                     if(y > 4)
 727                                         x++;
 728                                 }
 729                                 else
 730                                     x = 0;
 731
 732                                 // y = ((struct DeviceList *)BADDR(id.id_VolumeNode))->dl_DiskType;
 733
 734                                 //                              if(!y)
 735                                     y = id.id_DiskType;
 736
 737                                 if((idn->DosType & ID_DOS_DISK) != ID_DOS_DISK)
 738                                     y = idn->DosType;
 739
 740                                 LPrintf(DEVFMTSTR, "%4ld%% %4ld %-11s%-8s%s\n",
 741                                         x, id.id_NumSoftErrors,
 742                                         ((id.id_DiskState >= ID_WRITE_PROTECTED) && (id.id_DiskState <= ID_VALIDATED)) ?
 743                                         dstate[id.id_DiskState - ID_WRITE_PROTECTED] : (STRPTR)"", GetFSysStr(y), name);
 744
 745                                 if(blocks)
 746                                 {
 747                                     LPrintf(BLOCKSSTR,
 748                                             "\nTotal blocks: %-10ld  Blocks used: %ld\n"
 749                                             " Blocks free: %-10ld    Blocksize: %ld\n",
 750                                             id.id_NumBlocks, id.id_NumBlocksUsed,
 751                                             id.id_NumBlocks-id.id_NumBlocksUsed, id.id_BytesPerBlock );
 752                                 }
 753                             }
 754                             else
 755                                 D(bug("Info failure\n"));
 756
 757                             UnLock(lock);
 758                         }
 759
 760                         {
 761                             LONG err = IoErr();
 762
 763                             if((err != 0) && showall)
 764                             {
 765                                 LPrintf(~0, nfmtstr, name);
 766                                 PrintFault(err, NULL);
 767                             }
 768                         }
 769                     }
 770                 }
 771             }
 772
 773             /* show volumes */
 774             if(vols || (!devs && !disks))
 775             {
 776                 if(!first)
 777                     PutStr("\n");
 778
 779                 LPrintf(DISKSTITLE, "Volumes\n");
 780
 781                 for(MaxLen = 15, idn = head; idn; idn = idn->Next)
 782                 {
 783                     if(idn->IsVolume)
 784                     {
 785                         LONG len = strlen(idn->Name);
 786
 787                         if(len > MaxLen)
 788                             MaxLen = len;
 789                     }
 790                 }
 791
 792                 __sprintf(nfmtstr, "%%-%lds%%-10s", MaxLen+1);
 793
 794                 for(idn = head; idn; idn = idn->Next)
 795                 {
 796                     if(idn->IsVolume)
 797                     {
 798                         LPrintf(VOLNAMEFMTSTR, nfmtstr, idn->Name,
 799                                 GetStrFromCat(MOUNTEDSTR, "[Mounted]"));
 800                                 // idn->Task ? GetStrFromCat(MOUNTEDSTR, "[Mounted]") : ""); TODO
 801
 802                         if(datetimeFmt)
 803                         {
 804                             UBYTE datestr[128];
 805                             static struct Hook hook;
 806
 807                             memset(&hook, 0, sizeof(struct Hook));
 808
 809                             hook.h_SubEntry = (HOOKFUNC)FmtProcedure;
 810                             hook.h_Data = datestr;
 811
 812                             FormatDate(loc, datetimeFmt, &idn->VolumeDate, &hook);
 813
 814                             PutStr(datestr);
 815                         }
 816                         else
 817                         {
 818                             TEXT  StrDay[LEN_DATSTRING];
 819                             TEXT  StrDate[LEN_DATSTRING];
 820                             TEXT  StrTime[LEN_DATSTRING];
 821
 822                             struct DateTime dt;
 823
 824                             dt.dat_Flags   = DTF_SUBST;
 825                             dt.dat_Format  = FORMAT_DOS;
 826                             dt.dat_StrDay  = StrDay;
 827                             dt.dat_StrDate = StrDate;
 828                             dt.dat_StrTime = StrTime;
 829                             dt.dat_Stamp   = idn->VolumeDate;
 830
 831                             if(DateToStr(&dt))
 832                             {
 833                                 if(Strnicmp(StrDate, StrDay, strlen(StrDay)) == 0)
 834                                 {
 835                                     dt.dat_Flags = 0L;
 836                                     DateToStr(&dt);
 837                                 }
 838
 839                                 LPrintf(DATEFMTSTR, "created %.3s, %-10s %s",
 840                                         StrDay, StrDate, StrTime);
 841                             }
 842                         }
 843
 844                         PutStr("\n");
 845                     }
 846                 }
 847             }
 848         }
 849         else
 850         {
 851             PrintFault( ERROR_NO_FREE_STORE, NULL);
 852         }
 853
 854         /* reset window pointer of our process */
 855         proc->pr_WindowPtr = win;
 856
 857         /* free args */
 858         FreeArgs(rdargs);
 859     }
 860
 861
 862  end: /* free allocated memory */
 863
 864     DeletePool(Pool);
 865 }
 866
 867
 868 ULONG ComputeKBytes(ULONG a, ULONG b)
 869 {
 870     // UQUAD result = UMult64(a, b);
 871
 872     UQUAD result = (UQUAD)a * b;
 873
 874     return (ULONG)(result >> 10);
 875 }
 876
 877
 878 void FmtProcedure(struct Hook *hook, char a, struct Locale *locale)
 879 {
 880     *((STRPTR)hook->h_Data) = a;
 881     hook->h_Data = (STRPTR) hook->h_Data + 1;
 882 }
 883
 884
 885 ULONG ExtUDivMod32(ULONG a, ULONG b, ULONG *mod)
 886 {
 887     *mod = a % b;
 888
 889     return a/b;
 890 }