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