开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
wincfg.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：22k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

wincfg.cxx：源码内容
  1. /*
  2.  * wincfg.cxx
  3.  *
  4.  * Miscellaneous implementation of classes for Win32
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: wincfg.cxx,v $
  30.  * Revision 1.4  2000/05/25 11:08:46  robertj
  31.  * Added PConfig::HasKey() function to determine if value actually set.
  32.  * Fixed "system" PConfig to use the win.ini file in correct directory.
  33.  *
  34.  * Revision 1.3  1999/12/30 00:32:48  robertj
  35.  * Allowed absolute registry paths in PConfig::Application instances.
  36.  *
  37.  * Revision 1.2  1998/12/04 10:10:48  robertj
  38.  * Added virtual for determining if process is a service. Fixes linkage problem.
  39.  *
  40.  * Revision 1.1  1998/11/30 05:35:28  robertj
  41.  * Initial revision
  42.  *
  43.  */
  45. #include <ptlib.h>
  47. #include <winuser.h>
  48. #include <winnls.h>
  50. #include <process.h>
  51. #include <fcntl.h>
  52. #include <errno.h>
  53. #include <sysstat.h>
  55. #define new PNEW
  58. ///////////////////////////////////////////////////////////////////////////////
  59. // Configuration files
  61. class SecurityID
  62. {
  63.   public:
  64.     SecurityID(PSID_IDENTIFIER_AUTHORITY  pIdentifierAuthority, // pointer to identifier authority
  65.                BYTE nSubAuthorityCount, // count of subauthorities
  66.                DWORD dwSubAuthority0, // subauthority 0
  67.                DWORD dwSubAuthority1, // subauthority 1
  68.                DWORD dwSubAuthority2, // subauthority 2
  69.                DWORD dwSubAuthority3, // subauthority 3
  70.                DWORD dwSubAuthority4, // subauthority 4
  71.                DWORD dwSubAuthority5, // subauthority 5
  72.                DWORD dwSubAuthority6, // subauthority 6
  73.                DWORD dwSubAuthority7 // subauthority 7
  74.               )
  75.     {
  76.       if (!AllocateAndInitializeSid(pIdentifierAuthority, // pointer to identifier authority
  77.                                     nSubAuthorityCount, // count of subauthorities
  78.                                     dwSubAuthority0, // subauthority 0
  79.                                     dwSubAuthority1, // subauthority 1
  80.                                     dwSubAuthority2, // subauthority 2
  81.                                     dwSubAuthority3, // subauthority 3
  82.                                     dwSubAuthority4, // subauthority 4
  83.                                     dwSubAuthority5, // subauthority 5
  84.                                     dwSubAuthority6, // subauthority 6
  85.                                     dwSubAuthority7, // subauthority 7
  86.                                     &sidptr))
  87.         sidptr = NULL;
  88.     }
  90.     SecurityID(LPCTSTR lpSystemName, // address of string for system name
  91.                LPCTSTR lpAccountName, // address of string for account name
  92.                LPTSTR ReferencedDomainName, // address of string for referenced domain 
  93.                LPDWORD cbReferencedDomainName, // address of size of domain string
  94.                PSID_NAME_USE peUse  // address of SID-type indicator
  95.               )
  96.     {
  97.       DWORD len = 1024;
  98.       sidptr = (PSID)LocalAlloc(LPTR, len);
  99.       if (sidptr != NULL) {
  100.         if (!LookupAccountName(lpSystemName, // address of string for system name
  101.                                lpAccountName, // address of string for account name
  102.                                sidptr, // address of security identifier
  103.                                &len, // address of size of security identifier
  104.                                ReferencedDomainName, // address of string for referenced domain 
  105.                                cbReferencedDomainName, // address of size of domain string
  106.                                peUse  // address of SID-type indicator
  107.                               )) {
  108.           LocalFree(sidptr);
  109.           sidptr = NULL;
  110.         }
  111.       }
  112.     }
  113.     ~SecurityID()
  114.     {
  115.       FreeSid(sidptr);
  116.     }
  118.     operator PSID() const
  119.     {
  120.       return sidptr;
  121.     }
  123.     DWORD GetLength() const
  124.     {
  125.       return GetLengthSid(sidptr);
  126.     }
  128.     BOOL IsValid() const
  129.     {
  130.       return sidptr != NULL && IsValidSid(sidptr);
  131.     }
  133.   private:
  134.     PSID sidptr;
  135. };
  138. static DWORD SecureCreateKey(HKEY rootKey, const PString & subkey, HKEY & key)
  139. {
  140.   SECURITY_DESCRIPTOR secdesc;
  141.   if (!InitializeSecurityDescriptor(&secdesc, SECURITY_DESCRIPTOR_REVISION))
  142.     return GetLastError();
  144.   static SID_IDENTIFIER_AUTHORITY siaNTAuthority = SECURITY_NT_AUTHORITY;
  145.   SecurityID adminID(&siaNTAuthority, 2,
  146.                      SECURITY_BUILTIN_DOMAIN_RID,
  147.                      DOMAIN_ALIAS_RID_ADMINS, 
  148.                      0, 0, 0, 0, 0, 0);
  149.   if (!adminID.IsValid())
  150.     return GetLastError();
  152.   static SID_IDENTIFIER_AUTHORITY siaSystemAuthority = SECURITY_NT_AUTHORITY;
  153.   SecurityID systemID(&siaSystemAuthority, 1,
  154.                       SECURITY_LOCAL_SYSTEM_RID,
  155.                       0, 0, 0, 0, 0, 0, 0);
  156.   if (!systemID.IsValid())
  157.     return GetLastError();
  159.   static SID_IDENTIFIER_AUTHORITY siaCreatorAuthority = SECURITY_CREATOR_SID_AUTHORITY;
  160.   SecurityID creatorID(&siaCreatorAuthority, 1,
  161.                        SECURITY_CREATOR_OWNER_RID,
  162.                        0, 0, 0, 0, 0, 0, 0);
  163.   if (!creatorID.IsValid())
  164.     return GetLastError();
  166.   SID_NAME_USE snuType;
  167.   char szDomain[100];
  168.   DWORD cchDomainName = sizeof(szDomain);
  169.   SecurityID userID(NULL, PProcess::Current().GetUserName(),
  170.                     szDomain, &cchDomainName, &snuType);
  171.   if (!userID.IsValid())
  172.     return GetLastError();
  174.   DWORD acl_len = sizeof(ACL) + 4*sizeof(ACCESS_ALLOWED_ACE) +
  175.                     adminID.GetLength() + creatorID.GetLength() +
  176.                     systemID.GetLength() + userID.GetLength();
  177.   PBYTEArray dacl_buf(acl_len);
  178.   PACL dacl = (PACL)dacl_buf.GetPointer(acl_len);
  179.   if (!InitializeAcl(dacl, acl_len, ACL_REVISION2))
  180.     return GetLastError();
  182.   if (!AddAccessAllowedAce(dacl, ACL_REVISION2, KEY_ALL_ACCESS, adminID))
  183.     return GetLastError();
  185.   if (!AddAccessAllowedAce(dacl, ACL_REVISION2, KEY_ALL_ACCESS, systemID))
  186.     return GetLastError();
  188.   if (!AddAccessAllowedAce(dacl, ACL_REVISION2, KEY_ALL_ACCESS, creatorID))
  189.     return GetLastError();
  191.   if (!AddAccessAllowedAce(dacl, ACL_REVISION2, KEY_ALL_ACCESS, userID))
  192.     return GetLastError();
  194.   if (!SetSecurityDescriptorDacl(&secdesc, TRUE, dacl, FALSE))
  195.     return GetLastError();
  197.   SECURITY_ATTRIBUTES secattr;
  198.   secattr.nLength = sizeof(secattr);
  199.   secattr.lpSecurityDescriptor = &secdesc;
  200.   secattr.bInheritHandle = FALSE;
  202.   DWORD disposition;
  204.   return RegCreateKeyEx(rootKey, subkey, 0, "", REG_OPTION_NON_VOLATILE,
  205.                         KEY_ALL_ACCESS, &secattr, &key, &disposition);
  206. }
  209. RegistryKey::RegistryKey(const PString & subkeyname, OpenMode mode)
  210. {
  211.   PAssert(!subkeyname.IsEmpty(), PInvalidParameter);
  213.   PProcess & proc = PProcess::Current();
  214.   DWORD access = mode == ReadOnly ? KEY_READ : KEY_ALL_ACCESS;
  215.   DWORD error;
  217.   PString subkey;
  218.   HKEY basekey;
  219.   if (subkeyname.Find("HKEY_LOCAL_MACHINE\") == 0) {
  220.     subkey = subkeyname.Mid(19);
  221.     basekey = HKEY_LOCAL_MACHINE;
  222.   }
  223.   else if (subkeyname.Find("HKEY_CURRENT_USER\") == 0) {
  224.     subkey = subkeyname.Mid(18);
  225.     basekey = HKEY_CURRENT_USER;
  226.   }
  227.   else {
  228.     subkey = subkeyname;
  229.     PINDEX lastCharPos = subkey.GetLength()-1;
  230.     while (lastCharPos > 0 && subkey[lastCharPos] == '\')
  231.       subkey.Delete(lastCharPos--, 1);
  232.     basekey = NULL;
  234.     if (!proc.GetVersion(FALSE).IsEmpty()) {
  235.       PString keyname = subkey;
  236.       keyname.Replace("CurrentVersion", proc.GetVersion(FALSE));
  238.       error = RegOpenKeyEx(HKEY_CURRENT_USER, keyname, 0, access, &key);
  239.       if (error == ERROR_SUCCESS)
  240.         return;
  242.       PAssert(error != ERROR_ACCESS_DENIED, "Access denied accessing registry entry.");
  244.       error = RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyname, 0, access, &key);
  245.       if (error == ERROR_SUCCESS)
  246.         return;
  248.       PAssert(error != ERROR_ACCESS_DENIED, "Access denied accessing registry entry.");
  249.     }
  251.     error = RegOpenKeyEx(HKEY_CURRENT_USER, subkey, 0, access, &key);
  252.     if (error == ERROR_SUCCESS)
  253.       return;
  255.     PAssert(error != ERROR_ACCESS_DENIED, "Access denied accessing registry entry.");
  256.   }
  258.   error = RegOpenKeyEx(basekey != NULL ? basekey : HKEY_LOCAL_MACHINE,
  259.                        subkey, 0, access, &key);
  260.   if (error == ERROR_SUCCESS)
  261.     return;
  263.   PAssert(error != ERROR_ACCESS_DENIED, "Access denied accessing registry entry.");
  265.   key = NULL;
  266.   if (mode != Create)
  267.     return;
  269.   if (basekey == NULL) {
  270.     if (PProcess::Current().IsServiceProcess())
  271.       basekey = HKEY_LOCAL_MACHINE;
  272.     else
  273.       basekey = HKEY_CURRENT_USER;
  274.   }
  276.   error = SecureCreateKey(basekey, subkey, key);
  277.   if (error != ERROR_SUCCESS) {
  278.     DWORD disposition;
  279.     error = RegCreateKeyEx(basekey, subkey, 0, "", REG_OPTION_NON_VOLATILE,
  280.                            KEY_ALL_ACCESS, NULL, &key, &disposition);
  281.     if (error != ERROR_SUCCESS)
  282.       key = NULL;
  283.   }
  284. }
  287. RegistryKey::~RegistryKey()
  288. {
  289.   if (key != NULL)
  290.     RegCloseKey(key);
  291. }
  294. BOOL RegistryKey::EnumKey(PINDEX idx, PString & str)
  295. {
  296.   if (key == NULL)
  297.     return FALSE;
  299.   if (RegEnumKey(key, idx, str.GetPointer(MAX_PATH),MAX_PATH) != ERROR_SUCCESS)
  300.     return FALSE;
  302.   str.MakeMinimumSize();
  303.   return TRUE;
  304. }
  307. BOOL RegistryKey::EnumValue(PINDEX idx, PString & str)
  308. {
  309.   if (key == NULL)
  310.     return FALSE;
  312.   DWORD sizeofname = MAX_PATH;
  313.   if (RegEnumValue(key, idx, str.GetPointer(sizeofname),
  314.                          &sizeofname, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
  315.     return FALSE;
  317.   str.MakeMinimumSize();
  318.   return TRUE;
  319. }
  322. BOOL RegistryKey::DeleteKey(const PString & subkey)
  323. {
  324.   if (key == NULL)
  325.     return TRUE;
  327.   return RegDeleteKey(key, subkey) == ERROR_SUCCESS;
  328. }
  331. BOOL RegistryKey::DeleteValue(const PString & value)
  332. {
  333.   if (key == NULL)
  334.     return TRUE;
  336.   return RegDeleteValue(key, (char *)(const char *)value) == ERROR_SUCCESS;
  337. }
  340. BOOL RegistryKey::QueryValue(const PString & value, PString & str)
  341. {
  342.   if (key == NULL)
  343.     return FALSE;
  345.   DWORD type, size;
  346.   if (RegQueryValueEx(key, (char *)(const char *)value,
  347.                                     NULL, &type, NULL, &size) != ERROR_SUCCESS)
  348.     return FALSE;
  350.   switch (type) {
  351.     case REG_SZ :
  352.     case REG_MULTI_SZ :
  353.     case REG_EXPAND_SZ :
  354.     case REG_BINARY :
  355.       return RegQueryValueEx(key, (char *)(const char *)value, NULL,
  356.                   &type, (LPBYTE)str.GetPointer(size), &size) == ERROR_SUCCESS;
  358.     case REG_DWORD : {
  359.       DWORD num;
  360.       size = sizeof(num);
  361.       if (RegQueryValueEx(key, (char *)(const char *)value, NULL,
  362.                                 &type, (LPBYTE)&num, &size) == ERROR_SUCCESS) {
  363.         str = PString(PString::Signed, num);
  364.         return TRUE;
  365.       }
  366.     }
  367.     default :
  368.       PAssertAlways("Unsupported registry type.");
  369.   }
  370.   return FALSE;
  371. }
  374. BOOL RegistryKey::QueryValue(const PString & value, DWORD & num, BOOL boolean)
  375. {
  376.   if (key == NULL)
  377.     return FALSE;
  379.   DWORD type, size;
  380.   if (RegQueryValueEx(key, (char *)(const char *)value,
  381.                                     NULL, &type, NULL, &size) != ERROR_SUCCESS)
  382.     return FALSE;
  384.   switch (type) {
  385.     case REG_BINARY :
  386.       if (size > sizeof(DWORD))
  387.         return FALSE;
  389.       num = 0;
  390.       // Do REG_DWORD case
  392.     case REG_DWORD :
  393.       return RegQueryValueEx(key, (char *)(const char *)value, NULL,
  394.                                   &type, (LPBYTE)&num, &size) == ERROR_SUCCESS;
  396.     case REG_SZ : {
  397.       PString str;
  398.       if (RegQueryValueEx(key, (char *)(const char *)value, NULL,
  399.                 &type, (LPBYTE)str.GetPointer(size), &size) == ERROR_SUCCESS) {
  400.         num = str.AsInteger();
  401.         if (num == 0 && boolean) {
  402.           int c = toupper(str[0]);
  403.           num = c == 'T' || c == 'Y';
  404.         }
  405.         return TRUE;
  406.       }
  407.       break;
  408.     }
  409.     default :
  410.       PAssertAlways("Unsupported registry type.");
  411.   }
  413.   return FALSE;
  414. }
  417. BOOL RegistryKey::SetValue(const PString & value, const PString & str)
  418. {
  419.   if (key == NULL)
  420.     return FALSE;
  422.   return RegSetValueEx(key, (char *)(const char *)value, 0, REG_SZ,
  423.                 (LPBYTE)(const char *)str, str.GetLength()+1) == ERROR_SUCCESS;
  425. }
  428. BOOL RegistryKey::SetValue(const PString & value, DWORD num)
  429. {
  430.   if (key == NULL)
  431.     return FALSE;
  433.   return RegSetValueEx(key, (char *)(const char *)value,
  434.                      0, REG_DWORD, (LPBYTE)&num, sizeof(num)) == ERROR_SUCCESS;
  435. }
  438. void PConfig::Construct(Source src, const PString & appname, const PString & manuf)
  439. {
  440.   switch (src) {
  441.     case System :
  442.       source = Application;
  443.       if (appname.Find("HKEY_LOCAL_MACHINE\") == 0)
  444.         location = appname;
  445.       else if (appname.Find("HKEY_CURRENT_USER\") == 0)
  446.         location = appname;
  447.       else {
  448.         PString dir;
  449.         GetWindowsDirectory(dir.GetPointer(_MAX_PATH), _MAX_PATH);
  450.         Construct(PDirectory(dir)+"WIN.INI");
  451.       }
  452.       break;
  454.     case Application :
  455.       if (defaultSection.Find("HKEY_LOCAL_MACHINE\") == 0 || 
  456.           defaultSection.Find("HKEY_CURRENT_USER\") == 0)
  457.         source = Application;
  458.       else {
  459.         PProcess & proc = PProcess::Current();
  460.         PFilePath appFile = proc.GetFile();
  461.         PFilePath cfgFile = appFile.GetVolume() + appFile.GetPath() + appFile.GetTitle() + ".INI";
  462.         if (PFile::Exists(cfgFile))
  463.           Construct(cfgFile); // Make a file based config
  464.         else {
  465.           location = "SOFTWARE\";
  466.           if (!manuf)
  467.             location += manuf;
  468.           else if (!proc.GetManufacturer())
  469.             location += proc.GetManufacturer();
  470.           else
  471.             location += "PWLib";
  472.           location += PDIR_SEPARATOR;
  473.           if (appname.IsEmpty())
  474.             location += proc.GetName();
  475.           else
  476.             location += appname;
  477.           location += "\CurrentVersion\";
  478.           source = Application;
  479.         }
  480.       }
  481.       break;
  483.     default :
  484.       source = src;
  485.   }
  486. }
  489. void PConfig::Construct(const PFilePath & filename)
  490. {
  491.   location = filename;
  492.   source = NumSources;
  493. }
  496. static void RecurseRegistryKeys(const PString & location,
  497.                                 PINDEX baseLength,
  498.                                 PStringList &sections)
  499. {
  500.   RegistryKey registry(location, RegistryKey::ReadOnly);
  501.   PString name;
  502.   for (PINDEX idx = 0; registry.EnumKey(idx, name); idx++) {
  503.     RecurseRegistryKeys(location + name + '\', baseLength, sections);
  504.     sections.AppendString(location.Mid(baseLength) + name);
  505.   }
  506. }
  509. PStringList PConfig::GetSections() const
  510. {
  511.   PStringList sections;
  513.   switch (source) {
  514.     case Application :
  515.       RecurseRegistryKeys(location, location.GetLength(), sections);
  516.       break;
  518.     case NumSources :
  519.       PString buf;
  520.       char * ptr = buf.GetPointer(10000);
  521.       GetPrivateProfileString(NULL, NULL, "", ptr, 9999, location);
  522.       while (*ptr != '') {
  523.         sections.AppendString(ptr);
  524.         ptr += strlen(ptr)+1;
  525.       }
  526.       break;
  527.   }
  529.   return sections;
  530. }
  533. PStringList PConfig::GetKeys(const PString & section) const
  534. {
  535.   PStringList keys;
  537.   switch (source) {
  538.     case Environment : {
  539.       char ** ptr = _environ;
  540.       while (*ptr != NULL) {
  541.         PString buf = *ptr++;
  542.         keys.AppendString(buf.Left(buf.Find('=')));
  543.       }
  544.       break;
  545.     }
  547.     case Application : {
  548.       PAssert(!section.IsEmpty(), PInvalidParameter);
  549.       RegistryKey registry(location + section, RegistryKey::ReadOnly);
  550.       PString name;
  551.       for (PINDEX idx = 0; registry.EnumValue(idx, name); idx++)
  552.         keys.AppendString(name);
  553.       break;
  554.     }
  556.     case NumSources :
  557.       PAssert(!section.IsEmpty(), PInvalidParameter);
  558.       PString buf;
  559.       char * ptr = buf.GetPointer(10000);
  560.       GetPrivateProfileString(section, NULL, "", ptr, 9999, location);
  561.       while (*ptr != '') {
  562.         keys.AppendString(ptr);
  563.         ptr += strlen(ptr)+1;
  564.       }
  565.   }
  567.   return keys;
  568. }
  571. void PConfig::DeleteSection(const PString & section)
  572. {
  573.   switch (source) {
  574.     case Application : {
  575.       PAssert(!section.IsEmpty(), PInvalidParameter);
  576.       RegistryKey registry(location, RegistryKey::ReadWrite);
  577.       registry.DeleteKey(section);
  578.       break;
  579.     }
  581.     case NumSources :
  582.       PAssert(!section.IsEmpty(), PInvalidParameter);
  583.       PAssertOS(WritePrivateProfileString(section, NULL, NULL, location));
  584.   }
  585. }
  588. void PConfig::DeleteKey(const PString & section, const PString & key)
  589. {
  590.   PAssert(!key.IsEmpty(), PInvalidParameter);
  592.   switch (source) {
  593.     case Environment :
  594.       PAssert(key.Find('=') == P_MAX_INDEX, PInvalidParameter);
  595.       putenv(key + "=");
  596.       break;
  598.     case Application : {
  599.       PAssert(!section.IsEmpty(), PInvalidParameter);
  600.       RegistryKey registry(location + section, RegistryKey::ReadWrite);
  601.       registry.DeleteValue(key);
  602.       break;
  603.     }
  605.     case NumSources :
  606.       PAssert(!section.IsEmpty(), PInvalidParameter);
  607.       PAssertOS(WritePrivateProfileString(section, key, NULL, location));
  608.   }
  609. }
  612. BOOL PConfig::HasKey(const PString & section, const PString & key) const
  613. {
  614.   PAssert(!key.IsEmpty(), PInvalidParameter);
  616.   switch (source) {
  617.     case Environment :
  618.       return getenv(key) != NULL;
  620.     case Application : {
  621.       PAssert(!section.IsEmpty(), PInvalidParameter);
  622.       RegistryKey registry(location + section, RegistryKey::ReadOnly);
  623.       PString dummy;
  624.       return registry.QueryValue(key, dummy);
  625.     }
  627.     case NumSources :
  628.       PAssert(!section.IsEmpty(), PInvalidParameter);
  629.       static const char dflt[] = "<<<<<====---PConfig::DefaultValueString---====>>>>>";
  630.       PString str;
  631.       GetPrivateProfileString(section, key, dflt,
  632.                                         str.GetPointer(1000), 999, location);
  633.       return str != dflt;
  634.   }
  636.   return FALSE;
  637. }
  640. PString PConfig::GetString(const PString & section,
  641.                                const PString & key, const PString & dflt) const
  642. {
  643.   PAssert(!key.IsEmpty(), PInvalidParameter);
  645.   PString str;
  647.   switch (source) {
  648.     case Environment : {
  649.       PAssert(key.Find('=') == P_MAX_INDEX, PInvalidParameter);
  650.       char * env = getenv(key);
  651.       if (env != NULL)
  652.         str = env;
  653.       else
  654.         str = dflt;
  655.       break;
  656.     }
  658.     case Application : {
  659.       PAssert(!section.IsEmpty(), PInvalidParameter);
  660.       RegistryKey registry(location + section, RegistryKey::ReadOnly);
  661.       if (!registry.QueryValue(key, str))
  662.         str = dflt;
  663.       break;
  664.     }
  666.     case NumSources :
  667.       PAssert(!section.IsEmpty(), PInvalidParameter);
  668.       GetPrivateProfileString(section, key, dflt,
  669.                                         str.GetPointer(1000), 999, location);
  670.       str.MakeMinimumSize();
  671.   }
  673.   return str;
  674. }
  677. void PConfig::SetString(const PString & section,
  678.                                     const PString & key, const PString & value)
  679. {
  680.   PAssert(!key.IsEmpty(), PInvalidParameter);
  682.   switch (source) {
  683.     case Environment :
  684.       PAssert(key.Find('=') == P_MAX_INDEX, PInvalidParameter);
  685.       putenv(key + "=" + value);
  686.       break;
  688.     case Application : {
  689.       PAssert(!section.IsEmpty(), PInvalidParameter);
  690.       RegistryKey registry(location + section, RegistryKey::Create);
  691.       registry.SetValue(key, value);
  692.       break;
  693.     }
  695.     case NumSources :
  696.       PAssert(!section.IsEmpty(), PInvalidParameter);
  697.       PAssertOS(WritePrivateProfileString(section, key, value, location));
  698.   }
  699. }
  702. BOOL PConfig::GetBoolean(const PString & section,
  703.                                           const PString & key, BOOL dflt) const
  704. {
  705.   if (source != Application) {
  706.     PString str = GetString(section, key, dflt ? "T" : "F").ToUpper();
  707.     int c = toupper(str[0]);
  708.     return c == 'T' || c == 'Y' || str.AsInteger() != 0;
  709.   }
  711.   PAssert(!section.IsEmpty(), PInvalidParameter);
  712.   RegistryKey registry(location + section, RegistryKey::ReadOnly);
  714.   DWORD value;
  715.   if (!registry.QueryValue(key, value, TRUE))
  716.     return dflt;
  718.   return value != 0;
  719. }
  722. void PConfig::SetBoolean(const PString & section, const PString & key, BOOL value)
  723. {
  724.   if (source != Application)
  725.     SetString(section, key, value ? "True" : "False");
  726.   else {
  727.     PAssert(!section.IsEmpty(), PInvalidParameter);
  728.     RegistryKey registry(location + section, RegistryKey::Create);
  729.     registry.SetValue(key, value ? 1 : 0);
  730.   }
  731. }
  734. long PConfig::GetInteger(const PString & section,
  735.                                           const PString & key, long dflt) const
  736. {
  737.   if (source != Application) {
  738.     PString str(PString::Signed, dflt);
  739.     return GetString(section, key, str).AsInteger();
  740.   }
  742.   PAssert(!section.IsEmpty(), PInvalidParameter);
  743.   RegistryKey registry(location + section, RegistryKey::ReadOnly);
  745.   DWORD value;
  746.   if (!registry.QueryValue(key, value, FALSE))
  747.     return dflt;
  749.   return value;
  750. }
  753. void PConfig::SetInteger(const PString & section, const PString & key, long value)
  754. {
  755.   if (source != Application) {
  756.     PString str(PString::Signed, value);
  757.     SetString(section, key, str);
  758.   }
  759.   else {
  760.     PAssert(!section.IsEmpty(), PInvalidParameter);
  761.     RegistryKey registry(location + section, RegistryKey::Create);
  762.     registry.SetValue(key, value);
  763.   }
  764. }
  767. // End Of File ///////////////////////////////////////////////////////////////