home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ocl150a.zip / OCL / Source / OSysInfoVio.cpp < prev    next >
C/C++ Source or Header  |  1996-08-12  |  10KB  |  379 lines
  1. // OCL - OS/2 Class Library
  2. // (c) Cubus 1995
  3. // All Rights Reserved
  4. // OSysInfoVIO.cpp
  5. // System Utility Functions
  6.  
  7. // class member functions
  8.  
  9.  
  10. /*
  11.  * Redistribution and use in source and binary forms, with or without
  12.  * modification, are permitted provided that the following conditions
  13.  * are met:
  14.  * 1. Redistributions of source code must retain the above copyright
  15.  *    notice, this list of conditions and the following disclaimer.
  16.  * 2. Neither the name Cubus nor the name Team OCL may be used to
  17.  *    endorse or promote products derived from this software
  18.  *    without specific prior written permission.
  19.  * 3. See OCL.INF for a detailed copyright notice.
  20.  *
  21.  *              THIS SOFTWARE IS PROVIDED ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  33.  
  34. // $Header: W:/Projects/OCL/Source/rcs/OSysInfoVio.cpp 1.50 1996/08/11 23:49:32 B.STEIN Release $
  35.  
  36. #define __OCL_SOURCE__
  37.  
  38. #define OINCL_OSTRING
  39. #define OINCL_BASE
  40.  
  41. #include <ocl.hpp>
  42. #include <OSysInfo.hpp>
  43.  
  44. // Class OSysInfo
  45.  
  46.  
  47. OSysInfoVIO::OSysInfoVIO()
  48.   {}
  49.  
  50.  
  51. OSysInfoVIO::~OSysInfoVIO()
  52. {
  53.  SysInfoList.reset();
  54. }
  55.  
  56.  
  57. PSZ OSysInfoVIO::isOfType() const
  58. { 
  59.  return("OSysInfoVIO"); 
  60. }
  61.  
  62.  
  63. BOOL OSysInfoVIO::getDrives()
  64. {
  65.  ULONG   DriveNumber;
  66.  ULONG   LogicalDriveMap;
  67.  UCHAR   Drive[] = "C:";
  68.  ULONG   Temp;
  69.  HFILE   hfDiskHandle;
  70.  ULONG   Action;
  71.  CHAR    LABEL[30], tLABEL[30];
  72.  
  73.  if (DosQueryCurrentDisk(&DriveNumber, &LogicalDriveMap))
  74.     return(FALSE);
  75.  
  76.  for(Temp=(ULONG)Drive[0]-'A', LogicalDriveMap>>=2;
  77.      Temp<=(ULONG)('Z'-'A');
  78.      Temp++, Drive[0]++, LogicalDriveMap>>=1)
  79.       {
  80.        if(!(LogicalDriveMap&0x1))
  81.           continue;
  82.  
  83.        if (!DosOpen((PSZ)Drive, &hfDiskHandle, &Action, 0, FILE_NORMAL,
  84.                     OPEN_ACTION_OPEN_IF_EXISTS, OPEN_FLAGS_DASD |
  85.                     OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
  86.                     OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READONLY, 0))
  87.            {
  88.             struct _PPF
  89.              {
  90.               BYTE        bCommandInformation;
  91.               BYTE        bDriveUnit;
  92.              } PPF={0, 0};
  93.  
  94.             struct _DDF
  95.              {
  96.               BYTE        bData;
  97.              } DDF;
  98.  
  99.             ULONG       ulParamLengthInOut=sizeof(PPF);
  100.             ULONG       ulDataLengthInOut=sizeof(DDF);
  101.  
  102.             DosDevIOCtl(hfDiskHandle, IOCTL_DISK, DSK_BLOCKREMOVABLE,
  103.                         &PPF, ulParamLengthInOut, &ulParamLengthInOut,
  104.                         &DDF, ulDataLengthInOut, &ulDataLengthInOut);
  105.             DosClose(hfDiskHandle);
  106.             if(DDF.bData)
  107.               {
  108.                if (!DosQueryFSInfo(Drive[0]-'@', FSIL_VOLSER, tLABEL, sizeof(tLABEL)))
  109.                 sprintf(LABEL, " [%s]", &tLABEL[5]);
  110.               else
  111.                 strcpy(LABEL, " [ ]"); 
  112.              }
  113.            else
  114.               strcpy(LABEL, " [ ]");
  115.            SysInfoVar << (PSZ) Drive;
  116.            SysInfoVar + (PSZ) LABEL;
  117.            SysInfoList << SysInfoVar;
  118.           }
  119.      }
  120.  
  121.  return(TRUE);
  122. }
  123.  
  124.  
  125.  
  126. BOOL OSysInfoVIO::getAllDrives()
  127. {
  128.  ULONG   DriveNumber;
  129.  ULONG   LogicalDriveMap;
  130.  UCHAR   Drive[] = "C:";
  131.  ULONG   Temp;
  132.  HFILE   hfDiskHandle;
  133.  ULONG   Action;
  134.  CHAR    LABEL[30], tLABEL[30];
  135.  
  136.  if (DosQueryCurrentDisk(&DriveNumber, &LogicalDriveMap))
  137.     return(FALSE);
  138.  
  139.  for(Temp=(ULONG)Drive[0]-'A', LogicalDriveMap>>=2;
  140.      Temp<=(ULONG)('Z'-'A');
  141.      Temp++, Drive[0]++, LogicalDriveMap>>=1)
  142.       {
  143.        if(!(LogicalDriveMap&0x1))
  144.           continue;
  145.  
  146.        if (!DosOpen((PSZ)Drive, &hfDiskHandle, &Action, 0, FILE_NORMAL,
  147.                     OPEN_ACTION_OPEN_IF_EXISTS, OPEN_FLAGS_DASD |
  148.                     OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
  149.                     OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READONLY, 0))
  150.            {
  151.             struct _PPF
  152.              {
  153.               BYTE        bCommandInformation;
  154.               BYTE        bDriveUnit;
  155.              } PPF={0, 0};
  156.  
  157.             struct _DDF
  158.              {
  159.               BYTE        bData;
  160.              } DDF;
  161.  
  162.             ULONG       ulParamLengthInOut=sizeof(PPF);
  163.             ULONG       ulDataLengthInOut=sizeof(DDF);
  164.  
  165.             DosDevIOCtl(hfDiskHandle, IOCTL_DISK, DSK_BLOCKREMOVABLE,
  166.                         &PPF, ulParamLengthInOut, &ulParamLengthInOut,
  167.                         &DDF, ulDataLengthInOut, &ulDataLengthInOut);
  168.             DosClose(hfDiskHandle);
  169.             if(DDF.bData)
  170.               {
  171.                if (!DosQueryFSInfo(Drive[0]-'@', FSIL_VOLSER, tLABEL, sizeof(tLABEL)))
  172.                 sprintf(LABEL, " [%s]", &tLABEL[5]);
  173.                else
  174.                 strcpy(LABEL, " [ ]"); 
  175.              }
  176.            else
  177.               strcpy(LABEL, " [ ]");
  178.            SysInfoVar << (PSZ) Drive;
  179.            SysInfoVar + (PSZ) LABEL;
  180.            SysInfoList << SysInfoVar;
  181.           }
  182.       else
  183.        {  
  184.         strcpy(LABEL, " [ ]");
  185.         SysInfoVar << (PSZ) Drive;
  186.         SysInfoVar + (PSZ) LABEL;
  187.         SysInfoList << SysInfoVar;
  188.        }
  189.      }
  190.  
  191.  return(TRUE);
  192. }
  193.  
  194. // check if "Drive" is a non-removable local drive
  195.  
  196. BOOL OSysInfoVIO::checkRemovable(PCSZ Drive)
  197. {
  198.  HFILE    hfDiskHandle;
  199.  ULONG    Action;
  200.  OString  drive((PSZ)Drive);
  201.  
  202.  if (!DosOpen(drive, &hfDiskHandle, &Action, 0, FILE_NORMAL,
  203.               OPEN_ACTION_OPEN_IF_EXISTS, OPEN_FLAGS_DASD |
  204.               OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
  205.               OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READONLY, 0))
  206.    {
  207.     struct _PPF
  208.       {
  209.        BYTE        bCommandInformation;
  210.        BYTE        bDriveUnit;
  211.       } PPF={0, 0};
  212.  
  213.     struct _DDF
  214.       {
  215.        BYTE        bData;
  216.       } DDF;
  217.  
  218.      ULONG       ulParamLengthInOut=sizeof(PPF);
  219.      ULONG       ulDataLengthInOut=sizeof(DDF);
  220.  
  221.      DosDevIOCtl(hfDiskHandle, IOCTL_DISK, DSK_BLOCKREMOVABLE,
  222.                  &PPF, ulParamLengthInOut, &ulParamLengthInOut,
  223.                  &DDF, ulDataLengthInOut, &ulDataLengthInOut);
  224.      DosClose(hfDiskHandle);
  225.      if (DDF.bData) return(TRUE);
  226.   }
  227.  return(FALSE);
  228. }
  229.  
  230.  
  231. // get var from system environment
  232.  
  233. BOOL OSysInfoVIO::getEnv(PCSZ env)
  234. {
  235.  PCSZ Buffer = "";
  236.  
  237.  if(DosScanEnv(env, &Buffer))
  238.     return(FALSE);
  239.  else
  240.    {
  241.     SysInfoVar << (PSZ) Buffer;
  242.     return(TRUE);
  243.    }
  244. }
  245.  
  246.  
  247. // get boot drive
  248.  
  249. BOOL OSysInfoVIO::getBootDrive()
  250. {
  251.  ULONG      ulDrive;
  252.  UCHAR      Buffer[10];
  253.  
  254.  memset(&Buffer, 0, sizeof(Buffer));
  255.  
  256.  if(DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, &ulDrive, sizeof(ulDrive)))
  257.    return(FALSE);
  258.  else
  259.    {
  260.     Buffer[0] = (char) (ulDrive + 'A' - 1 ) ;
  261.     Buffer[1] = ':';
  262.     Buffer[2] = '\0';
  263.     SysInfoVar << (PSZ) Buffer;
  264.     return(TRUE);
  265.    }
  266. }
  267.  
  268.  
  269. // get an env string from config.sys
  270.  
  271. BOOL OSysInfoVIO::getCfgEnv(PSZ env)
  272. {
  273.  ifstream config;
  274.  PSZ      Buffer;
  275.  OString  a(env);
  276.  
  277.  strupr(a);
  278.  
  279.  if (DosAllocMem((PPVOID) &Buffer,  0x0000ffffL, PAG_READ | PAG_WRITE | PAG_COMMIT))
  280.    return(FALSE);
  281.  
  282.  if (getBootDrive())
  283.    {
  284.     SysInfoVar + (PSZ) "\\CONFIG.SYS";
  285.     config.open(SysInfoVar);
  286.     if (config.rdbuf())
  287.      {
  288.       while (config.getline(Buffer, 0x0000ffffL))
  289.        {
  290.         OString b(strupr(Buffer));
  291.  
  292.         if (strstr(b, a))
  293.          {
  294.           config.close();
  295.           SysInfoVar << Buffer;
  296.           DosFreeMem(Buffer);
  297.           return(TRUE);
  298.          }
  299.        }
  300.       config.close();
  301.      }
  302.    }
  303.  
  304.  DosFreeMem(Buffer);
  305.  
  306.  return(FALSE);
  307. }
  308.  
  309.  
  310. // find a file in path
  311.  
  312. BOOL OSysInfoVIO::findPathFile(PCSZ file)
  313. {
  314.  BYTE  Buffer[CCHMAXPATH];
  315.  
  316.  if (getEnv("PATH")) {
  317.    if (!DosSearchPath(SEARCH_CUR_DIRECTORY, SysInfoVar, (PSZ) file, Buffer, sizeof(Buffer))) {
  318.      SysInfoVar << (PSZ) Buffer;
  319.      return(TRUE); }}
  320.  return(FALSE);
  321. }
  322.  
  323. // get OS/2-Version
  324.  
  325. BOOL OSysInfoVIO::getOSVer()
  326. {
  327.  ULONG major;
  328.  ULONG minor;
  329.  CHAR  Buffer[10];
  330.  
  331.  if ((!DosQuerySysInfo(QSV_VERSION_MAJOR, QSV_VERSION_MAJOR, &major, sizeof(major))) &&
  332.      (!DosQuerySysInfo(QSV_VERSION_MINOR, QSV_VERSION_MINOR, &minor, sizeof(minor))) )
  333.   {
  334.    sprintf(Buffer, "%ld.%ld\0", major/10, minor);
  335.    SysInfoVar << (PSZ) Buffer;
  336.    return(TRUE);
  337.   }
  338.  
  339.  return(FALSE);
  340. }
  341.  
  342.  
  343. BOOL OSysInfoVIO::getOSVer(double& version)
  344. {
  345.  ULONG major;
  346.  ULONG minor;
  347.  
  348.  if ((!DosQuerySysInfo(QSV_VERSION_MAJOR, QSV_VERSION_MAJOR, &major, sizeof(major))) &&
  349.      (!DosQuerySysInfo(QSV_VERSION_MINOR, QSV_VERSION_MINOR, &minor, sizeof(minor))) )
  350.   {
  351.    version = minor;
  352.    version /= 100;
  353.    version += major/10;
  354.    return(TRUE);
  355.   }
  356.  return(FALSE);
  357. }
  358.  
  359.  
  360. BOOL OSysInfoVIO::clearRDOnly(PCSZ FileName)
  361. {
  362.  FILESTATUS  FileInfoBuf;
  363.  APIRET        rc=3;
  364.  
  365.  if (!DosQueryPathInfo((PSZ) FileName, 1, &FileInfoBuf, sizeof(FILESTATUS)))
  366.    {
  367.     FileInfoBuf.attrFile = FILE_NORMAL;
  368. #ifdef __BCPLUSPLUS__
  369.     rc = DosSetPathInfo((PSZ)FileName, 1, &FileInfoBuf, sizeof(FILESTATUS), DSPI_WRTTHRU);
  370. #else
  371.     rc = DosSetPathInfo(FileName, 1, &FileInfoBuf, sizeof(FILESTATUS), DSPI_WRTTHRU);
  372. #endif
  373.    }
  374.  return((rc==0) || (rc==2));
  375. }
  376.  
  377.  
  378. // end of source
  379.