workbench/c/Info.c

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