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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
xmlconfig.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：60k
源码类别：

Symbian

开发平台：

Visual C++

xmlconfig.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: xmlconfig.cpp,v 1.9.22.1 2004/07/19 21:04:07 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  51. //  $Id: xmlconfig.cpp,v 1.9.22.1 2004/07/19 21:04:07 hubbe Exp $
  53. #ifdef _UNIX 
  54. #include <sys/stat.h> 
  55. #endif 
  57. #include "hxtypes.h"
  58. #include "hxcom.h"
  59. #include "looseprs.h"
  60. #include "cbbqueue.h"
  61. #include "hxstrutl.h"
  62. #include "ihxpckts.h"
  63. #include "chxpckts.h"
  64. #include "hxmon.h" // for registry property type enums
  65. #include "hxerror.h"
  66. #include "xmlconfig.h"
  67. #include "errmsg_macros.h"
  69. #define MAX_TAG_SIZE 32768
  70. #define MAX_ERROR_CHARS 20 // Number of chars to print if an error occurs
  72. static const XMLConfigAlias aliases[] = {
  73.     //Note: Attribute specs here should not have quotes in them!
  74.     //      %0 is replaced with the name of the alias (leftmost column)
  75.     //      %n with the value of the nth attribute
  76.     //      %  args can only appear in the values of attributes
  77.     
  78.     //Alias This Tag    To This         With these 3 args      and these flags
  79.     {"FSMount", "List", "Name=FSMount", NULL, NULL,         0},
  80.     {"Plugin",          "List", "Name=%1",      NULL, NULL,         0},
  81.     {"MimeTypes",       "List", "Name=MimeTypes", NULL, NULL,       0},
  82.     {"Type",            "List", "Name=%1",      NULL, NULL,         0},
  83.     {"Ext",             "Var",  NULL,           NULL, NULL,         0},
  84.     {"IPBindings",      "List", "Name=IPBindings", NULL, NULL,      0},
  85.     {"HTTPDeliverable", "List", "Name=HTTPDeliverable", NULL, NULL,      0},
  86.     {"Path",      "Var", NULL, NULL, NULL,     0},
  87.     {"ConnectControl",  "List", "Name=ConnectControl", NULL, NULL,  0},
  88.     {"Multicast", "List", "Name=Multicast", NULL, NULL,0},
  89.     {"Address",         "Var",  NULL,           NULL, NULL,         0},
  90.     {"NetMask",         "Var",  NULL,           NULL, NULL,         0},
  91.     {"AccessLogging",   "List", "Name=AccessLogging", NULL, NULL,   0},
  92.     {"LiveArchive",     "List", "Name=LiveArchive", NULL, NULL,     0},
  93.     {"FarmSplit",       "List", "Name=FarmSplit", NULL, NULL,     0},
  94.     {"Directory",       "List", "Name=%1",      NULL, NULL,         0},
  95.     {"AccessControl",   "List", "Name=AccessControl", NULL, NULL,     0},
  96.     {"Rule",      "List", "Name=%1", NULL, NULL,     0},
  97.     {"Access",      "Var", NULL, NULL, NULL,     0},
  98.     {"Transmission",    "Var",  NULL, NULL, NULL,     0},
  99.     {"To",      "Var", NULL, NULL, NULL,     0},
  100.     {"From",      "Var", NULL, NULL, NULL,     0},
  101.     {"Ports",      "List", "Name=Ports", NULL, NULL,     0},
  102.     {"Num",      "Var", NULL, NULL, NULL,     0},
  103.     {"Proxy",      "List", "Name=Proxy", NULL, NULL,     0},
  104.     {NULL, NULL, NULL, NULL, NULL, 0}
  105. };
  107. #if defined (_WINDOWS ) || defined (_WIN32) || defined(_SYMBIAN)
  108. #define OS_SEPARATOR_CHAR '\'
  109. #define OS_SEPARATOR_STRING "\"
  110. #elif defined (_UNIX)
  111. #define OS_SEPARATOR_CHAR '/'
  112. #define OS_SEPARATOR_STRING "/"
  113. #elif defined (_MACINTOSH) 
  114. #ifdef _MAC_MACHO
  115. #define OS_SEPARATOR_CHAR       '/' 
  116. #define OS_SEPARATOR_STRING     "/" 
  117. #else
  118. #define OS_SEPARATOR_CHAR       ':' 
  119. #define OS_SEPARATOR_STRING     ":" 
  120. #endif
  121. #endif // defined (_WINDOWS ) || defined (_WIN32)
  123. XMLConfig::XMLConfigListNode::~XMLConfigListNode()
  124. {
  125.     if(m_pList)
  126.     {
  127. delete m_pList;
  128.     }
  129.     if(m_name)
  130. delete [] m_name;
  131.     if(m_value)
  132. delete [] m_value;
  133. }
  135. XMLConfig::XMLConfigList::~XMLConfigList()
  136. {
  137.     CHXSimpleList::Iterator i;
  139.     for(i = Begin(); i != End(); ++i)
  140.     {
  141. XMLConfigListNode* node = (XMLConfigListNode*)(*i);
  142. delete node;
  143.     }
  144. }
  146. XMLConfig::XMLConfig():m_filename(NULL), m_lRefCount(0), m_pList(NULL),
  147.                        m_ulMajor(0), m_ulMinor(0), m_ActiveSetsOutstanding(0),
  148.                        m_pRegistry(NULL), m_pMessages(NULL), m_szServerversion(NULL),
  149.                        m_pReconfigureResponse(NULL)
  150. {
  151. }
  153. XMLConfig::XMLConfig(IHXRegistry2* pRegistry, IHXErrorMessages* pMessages, const char* szserverversion,
  154.                      UINT32 dwMajor, UINT32 dwMinor)
  155.      : m_filename(0), m_lRefCount(0), m_pList(NULL), m_ulMajor(dwMajor), m_ulMinor(dwMinor)
  156.        , m_ActiveSetsOutstanding(0), m_pReconfigureResponse(NULL)
  157. {
  158.     if (pRegistry)
  159.     {
  160.         m_pRegistry = pRegistry;
  161.         m_pRegistry->AddRef();
  162.     }
  164.     if (pMessages)
  165.     {
  166.         m_pMessages = pMessages;
  167.         m_pMessages->AddRef(); 
  168.     }
  170.     m_szServerversion = new_string(szserverversion);
  171.     
  172.     XMLConfigAlias* alias = (XMLConfigAlias*) &aliases[0];
  173.     char lwr[256]; /* Flawfinder: ignore */
  174.     m_vserver = -1;
  176.     while(alias->from)
  177.     {
  178. SafeStrCpy(lwr, alias->from, 256);
  179. strlwr(lwr);
  180. m_alias_dict.enter(lwr, alias);
  181. alias++;
  182.     }
  183. }
  184. XMLConfig::~XMLConfig()
  185. {
  186.     delete[] m_szServerversion; 
  187.     HX_RELEASE(m_pReconfigureResponse);
  188.     HX_RELEASE(m_pRegistry);
  189.     HX_RELEASE(m_pMessages); 
  190. }
  192. HX_RESULT
  193. XMLConfig::init(IHXRegistry2* pRegistry, IHXErrorMessages* pMessages, const char* szserverversion,
  194.                      UINT32 dwMajor, UINT32 dwMinor)
  195. {
  196.     m_ulMajor = dwMajor;
  197.     m_ulMinor = dwMinor;
  198.     if (pRegistry)
  199.     {
  200.         m_pRegistry = pRegistry;
  201.         m_pRegistry->AddRef();
  202.     }
  204.     if (pMessages)
  205.     {
  206.         m_pMessages = pMessages;
  207.         m_pMessages->AddRef(); 
  208.     }
  210.     m_szServerversion = new_string(szserverversion);
  211.     
  212.     XMLConfigAlias* alias = (XMLConfigAlias*) &aliases[0];
  213.     char lwr[256]; /* Flawfinder: ignore */
  214.     m_vserver = -1;
  216.     while(alias->from)
  217.     {
  218. SafeStrCpy(lwr, alias->from, 256);
  219. strlwr(lwr);
  220. m_alias_dict.enter(lwr, alias);
  221. alias++;
  222.     }
  223.     return HXR_OK;
  224. }
  226. STDMETHODIMP
  227. XMLConfig::QueryInterface(REFIID riid, void** ppvObj)
  228. {
  229.     if(IsEqualIID(riid, IID_IUnknown))
  230.     {
  231.         AddRef();
  232.         *ppvObj = (IUnknown*)(IHXRegConfig*)this;
  233.         return HXR_OK;
  234.     }
  235.     else if (IsEqualIID(riid, IID_IHXRegConfig))
  236.     {
  237. AddRef();
  238. *ppvObj = (IHXRegConfig*)this;
  239. return HXR_OK;
  240.     }
  242.     *ppvObj = NULL;
  243.     return HXR_NOINTERFACE;
  244. }
  246. STDMETHODIMP_(UINT32)
  247. XMLConfig::AddRef()
  248. {
  249.     return InterlockedIncrement(&m_lRefCount);    
  250. }
  252. STDMETHODIMP_(UINT32)
  253. XMLConfig::Release()
  254. {
  255.     if (InterlockedDecrement(&m_lRefCount) > 0)
  256.     {
  257.         return m_lRefCount;
  258.     }
  260.     delete this;
  261.     return 0;
  262. }
  264. HX_RESULT
  265. XMLConfig::Write(const char* name, const char* filename)
  266. {
  267.     FILE* outfile = fopen(filename, "w");
  268.     if(!outfile)
  269.     {
  270. return HXR_INVALID_FILE;
  271.     }
  273.     fprintf(outfile, "<?XML Version="1.0" ?>n");
  274.     fprintf(outfile, "<!-- Auto generated by %s %d.%d -->nn",
  275.             m_szServerversion, m_ulMajor, m_ulMinor);
  277. #ifdef _UNIX
  278.     chmod(filename, 0700);
  279. #endif //UNIX
  281.     return DumpConfig(name, 0, outfile, m_pRegistry);
  282. }
  284. HX_RESULT
  285. XMLConfig::DumpConfig(const char* name, int indent, FILE* outfile,
  286.       IHXRegistry2* pRegistry)
  287. {
  288.     IHXValues* pValues;
  289.     const char* propName;
  290.     HX_RESULT res;
  291.     UINT32 prop_id;
  293.     if(HXR_OK != pRegistry->GetPropListByName(name,
  294.   pValues))
  295. return HXR_FAIL;
  297.     char* point = (char*)strrchr(name, '.');
  298.     if(point)
  299.     {
  300. if(strcasecmp(point + 1, "XXXBADLIST") == 0)
  301.     return HXR_FAIL;
  303. for(int j = 0; j < indent - 1; j++)
  304.     fprintf(outfile, "  ");
  305. fprintf(outfile, "<List %s>n", point + 1);
  306.     }
  307.     
  308.     res = pValues->GetFirstPropertyULONG32(propName, prop_id);
  309.     while(res == HXR_OK)
  310.     {
  311. HXPropType type = pRegistry->GetTypeById(prop_id);
  312. switch(type)
  313. {
  314.     case PT_COMPOSITE:
  315. DumpConfig(propName, indent+1, outfile, pRegistry);
  316. break;
  317.     case PT_INTEGER:
  318.     {
  319. INT32 val;
  320. if(HXR_OK == pRegistry->GetIntById(prop_id, val))
  321. {
  322.     
  323.     fprintf(outfile, "%*.*s<Var %s="%ld"/>n",
  324.     indent * 2, indent * 2, "  ",
  325.     strrchr(propName, '.') + 1,
  326.     val);
  327. }
  328. break;
  329.     }
  330.     case PT_INTREF:
  331. break;
  332.     case PT_STRING:
  333.     {
  334. IHXBuffer* pBuffer;
  335. if(HXR_OK == pRegistry->GetStrById(prop_id, pBuffer) && pBuffer)
  336. {
  337.     fprintf(outfile, "%*.*s<Var %s="%s"/>n",
  338.     indent * 2, indent * 2, "  ",
  339.     strrchr(propName, '.') + 1,
  340.     pBuffer->GetBuffer());
  341.     pBuffer->Release();
  342. }
  343. break;
  344.     }
  345.     case PT_BUFFER:
  346.     {
  347. IHXBuffer* pBuffer;
  348. pRegistry->GetBufById(prop_id, pBuffer);
  349. if(pBuffer)
  350. {
  351.     fprintf(outfile, "%*.*s<Var %s="%s"/>n",
  352.     indent * 2, indent * 2, "  ",
  353.     strrchr(propName, '.') + 1,
  354.     pBuffer->GetBuffer());
  355.     pBuffer->Release();
  356. }
  357. break;
  358.     }
  359.     case PT_UNKNOWN:
  360.     default:
  361. break;
  362. }
  364. res = pValues->GetNextPropertyULONG32(propName, prop_id);
  365.     }
  366.     if(point)
  367. fprintf(outfile, "%*.*s</List>n", (indent - 1) * 2, (indent-1)*2, "  ");
  368.     fflush(outfile);
  369.     pValues->Release();
  370.     return HXR_OK;
  371. }
  373. void
  374. XMLConfig::ExpandAttribute(XMLTag* tag, const char* attribute)
  375. {
  376.     const char* equals;
  377.     char subst[2048]; /* Flawfinder: ignore */
  378.     const char* a;
  379.     UINT32 arg;
  380.     UINT32 i;
  382.     equals = strchr(attribute, '=');
  383.     // Aliases are hardcoded.  Don't enter wrong ones, dumbass.
  384.     HX_ASSERT(equals);
  386.     tag->new_attribute()->name = new char[equals - attribute + 1];
  387.     strncpy(tag->m_cur_attribute->name, attribute, /* Flawfinder: ignore */
  388.     equals - attribute);
  389.     tag->m_cur_attribute->name[equals - attribute] = 0;
  391.     // Attributes already present in the tag with the same name
  392.     // as an aliased attribute override the alias.
  393.     for(i = 0; i < tag->m_numAttributes - 1; i++)
  394.     {
  395. if(tag->attribute(i)->name && 
  396.    (strcasecmp(tag->attribute(i)->name, 
  397.        tag->m_cur_attribute->name) == 0))
  398. {
  399.     break;
  400. }
  401.     }
  402.     if(i < tag->m_numAttributes - 1)
  403.     {
  404. // Found a duplicate attribute with this name, throw out the
  405. // alias version.
  406. delete tag->m_cur_attribute;
  407. tag->m_numAttributes--;
  408.     }
  409.     else if(!strchr(equals, '%'))
  410.     {
  411. tag->m_cur_attribute->value = new_string(equals+1);
  412.     }
  413.     else
  414.     {
  415. for(a = equals, i = 0; *a; a++, i++)
  416. {
  417.     switch(*a)
  418.     {
  419. case '%':
  420.     arg = *(a+1) - '0';
  421.     if(arg > 0)
  422.     {
  423. if(arg - 1 < tag->m_numAttributes)
  424. {
  425.     SafeStrCpy(&subst[i], tag->attribute(arg - 1)->value, 2048-i);
  426.     i+= strlen(tag->attribute(arg - 1)->value);
  427. }
  428. else
  429. {
  430.     ERRMSG(m_pMessages,
  431.    "%s: Alias %s requires at least %d arguments",
  432.    m_filename,
  433.    tag->m_name, arg);
  434.     return;
  435. }
  436.     }
  437.     else
  438.     {
  439. SafeStrCpy(&subst[i], tag->m_name, 2048-i);
  440. i += strlen(tag->m_name);
  441.     }
  442.     break;
  443. default:
  444.     subst[i] = *a;
  445.     }
  446. }
  447. subst[i] = 0;
  448. tag->m_cur_attribute->value = new_string(subst);
  449.     }
  450. }
  452. // XMLConfig::Expand
  453. //
  454. // Do alias and loose syntax expansion
  455. BOOL
  456. XMLConfig::Expand(XMLTag* tag, CBigByteQueue* queue)
  457. {
  458.     UINT32 i;
  460.     Dict_entry* ent;
  461.     XMLConfigAlias* alias;
  462.     char* lwr = new char[strlen(tag->m_name) + 1];
  463.     BOOL ignore = FALSE;
  465.     strcpy(lwr, tag->m_name); /* Flawfinder: ignore */
  466.     strlwr(lwr);
  467.     if((ent = m_alias_dict.find(lwr)) != NULL)
  468.     {
  469. alias = (XMLConfigAlias*)ent->obj;
  470. delete [] tag->m_name;
  471. tag->m_name = new_string(alias->to);
  472. if(tag->m_type == XMLPlainTag)
  473. {
  474.     if(alias->attr1)
  475.     {
  476. ExpandAttribute(tag, alias->attr1);
  477.     }
  478.     if(alias->attr2)
  479.     {
  480. ExpandAttribute(tag, alias->attr2);
  481.     }
  482.     if(alias->attr3)
  483.     {
  484. ExpandAttribute(tag, alias->attr3);
  485.     }
  486. }
  487. if((alias->flags & AL_TAGIFY) && (tag->m_type != XMLEndTag))
  488. {
  489.     UINT32 bytesAvail = queue->GetQueuedItemCount();
  490.     BYTE* buf = new BYTE[bytesAvail];
  491.     queue->DeQueue(buf, bytesAvail);
  492.     BOOL isList = FALSE;
  493.     char ibuf[1024]; /* Flawfinder: ignore */
  495.     if(!tag->m_need_close && strcasecmp(alias->to, "list") == 0)
  496.     {
  497. isList = TRUE;
  498. ignore = TRUE;
  499. if(tag->get_attribute("name"))
  500.     SafeSprintf(ibuf, 1024, "<List Name="%s">",
  501.     tag->get_attribute("name"));
  502. else
  503.     SafeSprintf(ibuf, 1024, "<List Name="%s">",
  504.     alias->from);
  505. queue->EnQueue(ibuf, strlen(ibuf));
  506.     }
  507.     UINT32 i;
  508.     for(i = 0; i < tag->m_numAttributes; i++)
  509.     {
  510. if (tag->attribute(i)->name)
  511. {
  512.     SafeSprintf(ibuf, 1024, "<Var Name="%s" Value="%s"/>",
  513.    (tag->attribute(i)->name ? tag->attribute(i)->name : ""),
  514.     tag->attribute(i)->value);
  515.     queue->EnQueue(ibuf, strlen(ibuf));
  516. }
  517.     }
  518.     if(isList)
  519.     {
  520. sprintf(ibuf, "</List>"); /* Flawfinder: ignore */
  521. queue->EnQueue(ibuf, strlen(ibuf));
  522.     }
  523.     queue->EnQueue(buf, bytesAvail);
  524. }
  525.     }
  526.     delete [] lwr;
  528.     if(tag->m_type != XMLPlainTag || ignore)
  529. return ignore;
  531.     if(strcasecmp(tag->m_name, "list") == 0)
  532.     {
  533. if(tag->m_numAttributes < 1)
  534. {
  535.     return ignore;
  536. }
  538. for(i = 0; i < tag->m_numAttributes; i++)
  539. {
  540.     if(!tag->attribute(i)->name)
  541.     {
  542. tag->attribute(i)->name = new_string("name");
  543.     }
  544.     else if(strcasecmp(tag->attribute(i)->name, "name") != 0)
  545.     {
  546. ERRMSG(m_pMessages,
  547.        "%s: Unknown List Attribute %s",
  548.        m_filename,
  549.        tag->attribute(i)->name);
  550. return ignore;
  551.     }
  552. }
  553.     }
  554.     else if(strcasecmp(tag->m_name, "var") == 0)
  555.     {
  556. if(tag->m_numAttributes < 1)
  557. {
  558.     ERRMSG(m_pMessages,
  559.    "%s: Var tag requires at least one attribute",
  560.    m_filename);
  561.     return ignore;
  562. }
  564. if(tag->m_numAttributes == 1)
  565. {
  566.     // Special case, <Var x=y> converts to <Var name=x value=y>
  567.     tag->new_attribute()->name = new_string("value");
  568.     tag->attribute(1)->value = tag->attribute(0)->value;
  569.     tag->attribute(0)->value = tag->attribute(0)->name;
  570.     if(!tag->attribute(0)->value)
  571.     {
  572. char* val = new char[20];
  573. sprintf(val, "elem%ld", tag->elem); /* Flawfinder: ignore */
  574. tag->attribute(0)->value = val;
  575.     }
  576.     tag->attribute(0)->name = new_string("name");
  577. }
  578.     }
  579.     else if(strcasecmp(tag->m_name, "server") == 0)
  580.     {
  581. if(tag->m_numAttributes < 1)
  582. {
  583.     ERRMSG(m_pMessages,
  584.    "%s: Server tag requires at least one attribute",
  585.    m_filename);
  586.     return ignore;
  587. }
  588. if(!tag->get_attribute("number"))
  589. {
  590.     tag->attribute(0)->name = new_string("number");
  591. }
  592.     }
  593.     return ignore;
  594. }
  596. XMLConfigVarType
  597. XMLConfig::GetVarType(XMLConfigListNode* node)
  598. {
  599.     char* pos = node->m_value;
  601.     if (0 == *pos)
  602.     {
  603.          return CfgVarString;
  604.     }
  605.     for(; *pos && isdigit(*pos); pos++)
  606. ;
  607.     if(*pos == 0 && *(node->m_value) != 0)
  608.     {
  609. node->m_int = atol(node->m_value);
  610. return CfgVarInt;
  611.     }
  612.     
  613.     if(strcasecmp(node->m_value, "true") == 0)
  614.     {
  615. node->m_bool = TRUE;
  616. return CfgVarBool;
  617.     }
  618.     else if(strcasecmp(node->m_value, "false") == 0)
  619.     {
  620. node->m_bool = FALSE;
  621. return CfgVarBool;
  622.     }
  623.     return CfgVarString;
  624. }
  626. void
  627. XMLConfig::StuffRegistry(XMLConfigList* list)
  628. {
  629.     CHXSimpleList::Iterator i;
  631.     char* regname = list->m_parentnode->get_registry_name();
  632.     if(m_pRegistry->GetTypeByName(regname) == PT_UNKNOWN)
  633.     { 
  634. m_pRegistry->AddComp(regname);
  635.     }
  636.     delete [] regname;
  638.     for(i = list->Begin(); i != list->End(); ++i)
  639.     {
  640. XMLConfigListNode* node = (XMLConfigListNode*)(*i);
  641. switch(node->m_type)
  642. {
  643.     case CfgVar:
  644. regname = node->get_registry_name();
  645. switch(GetVarType(node))
  646. {
  647.     case CfgVarInt:
  648. // printf("%s = %ldn", regname, node->m_int);
  649.                         if(m_pRegistry->GetTypeByName(regname) == PT_UNKNOWN)
  650. {
  651.     m_pRegistry->AddInt(regname, node->m_int);
  652. }
  653. else
  654. {
  655.     m_pRegistry->SetIntByName(regname, node->m_int);
  656. }
  657. break;
  658.     case CfgVarString:
  659.     {
  660. CHXBuffer* pBuffer = new CHXBuffer;
  661. pBuffer->AddRef();
  662. pBuffer->Set((UINT8*)node->m_value,
  663.      strlen(node->m_value) + 1);
  664. // printf("%s = %sn", regname, (const char *)pBuffer->GetBuffer());
  665. if(m_pRegistry->GetTypeByName(regname) == PT_UNKNOWN)
  666. {
  667.     m_pRegistry->AddStr(regname, pBuffer);
  668. }
  669. else
  670. {
  671.     m_pRegistry->SetStrByName(regname, pBuffer);
  672. }
  673. pBuffer->Release();
  674. break;
  675.     }
  676.     case CfgVarBool:
  677. // printf("%s = %ldn", regname, node->m_bool);
  678. if(m_pRegistry->GetTypeByName(regname) == PT_UNKNOWN)
  679. {
  680.     m_pRegistry->AddInt(regname, node->m_bool);
  681. }
  682. else
  683. {
  684.     m_pRegistry->SetIntByName(regname, node->m_bool);
  685. }
  686. break;
  687. }
  688. delete [] regname;
  689. break;
  690.     case CfgList:
  691. StuffRegistry(node->m_pList);
  692. break;
  693. }
  694.     }
  695. }
  698. // 
  699. // Method: Read
  700. //
  701. // Parameters:
  702. //
  703. // filename:    The file to be read.
  704. // pWinRegKey:  The Windows registry key to be filled in (can be
  705. //   NULL if no registry writing is needed).
  706. // pServRegKey: The Server registry key to be filled in.
  707. // 
  708. // Notes: the bIncludedFile is for internal recursive use only.  Do not 
  709. // set it when calling from outside this object.
  710. HX_RESULT
  711. XMLConfig::Read(char* filename, 
  712. char* pServRegKey, 
  713. BOOL  bIncludedFile)
  714. {
  715.     HX_RESULT hResult = HXR_OK;
  716.     FILE* fp=0;
  717.     XMLParser parser;
  718.     XMLTag*   tag = 0;
  719.     CBigByteQueue queue(MAX_TAG_SIZE);
  720.     int l=0;
  721.     BOOL filedone = FALSE;
  722.     UINT32 indent = 0;
  724.     HX_ASSERT(filename && strlen(filename));
  726.     HX_VECTOR_DELETE(m_filename);
  727.     m_filename = new_string(filename);
  729.     fp = fopen(filename, "r");
  730.     if (!fp)
  731.     {
  732. ERRMSG(m_pMessages, "%s: file not found", filename);
  733. return HXR_FILE_NOT_FOUND;
  734.     }
  736.     if(!m_pList)
  737.     {
  738. m_pList = new XMLConfigList;
  739. m_pList->m_parentnode = new XMLConfigListNode;
  740. m_pList->m_parentnode->m_name = new_string(pServRegKey);
  741. m_pList->m_parentnode->m_parent = NULL;
  742.     }
  744.     // read the config file into the byte queue
  745.     INT32 nBufSize = 16384;
  746.     BYTE* pBuf = new BYTE[nBufSize];
  747.     while (!filedone && hResult == HXR_OK)
  748.     {
  749.         l = fread(pBuf, 1, nBufSize, fp);
  750.         if (l > 0)
  751.         {
  752.     if (!queue.EnQueue(pBuf, l))
  753.             {
  754.                 if (!queue.Grow(l))
  755.                 {
  756.                     ERRMSG(m_pMessages,
  757.                            "error expanding data structure while parsing %s",
  758.                            filename);
  759.                     hResult = HXR_FAIL;
  760.                 }
  761.                 if (!queue.EnQueue(pBuf, l))
  762.                 {
  763.                     ERRMSG(m_pMessages,
  764.                            "unknown error while parsing %s",
  765.                            filename);
  766.                     hResult = HXR_FAIL;
  767.                 }
  768.             }
  769.         }
  770.         else
  771.         {
  772.          filedone = TRUE;
  773.         }
  774.     }
  776.     UINT32 bytesUsed=0;
  777.     UINT32 bytesAvail=0;
  778.     BYTE* p=0;
  779.     while (hResult == HXR_OK && (bytesAvail = queue.GetQueuedItemCount()) > 0)
  780.     {
  781. if (bytesAvail > nBufSize)
  782.         {
  783.             HX_VECTOR_DELETE(pBuf);
  784.             pBuf = new BYTE[bytesAvail];
  785.             nBufSize = bytesAvail;
  786.         }
  787. p = pBuf;
  789. queue.DeQueue(pBuf, bytesAvail);
  790. bytesUsed = bytesAvail;
  792.         HX_DELETE(tag);
  793. XMLParseResult res = parser.Parse((const char*&)p, bytesAvail, tag);
  794. queue.EnQueue(p, bytesAvail - (p - pBuf));
  796. switch(res)
  797. {
  798.     case XMLPNoClose:
  799. // A tag opener was found, but no closer yet.
  800. if (filedone)
  801. {
  802.     pBuf[bytesAvail - 1] = '';
  803.     if (bytesAvail > MAX_ERROR_CHARS)
  804.     {
  805. pBuf[MAX_ERROR_CHARS - 1] = '';
  806.     }
  807.     ERRMSG(m_pMessages,
  808.     "%s: Missing close for tag '%s'...", m_filename, pBuf);
  809.     hResult = HXR_FAIL;
  810. }
  811. break;
  812.     case XMLPNoTagType:
  813. *p = 0;
  814. ERRMSG(m_pMessages,
  815.        "%s: Badly formed tag '%s'", m_filename, pBuf);
  816. break;
  817.     case XMLPBadAttribute:
  818. *p = 0;
  819. ERRMSG(m_pMessages,
  820.        "%s: Badly formed attribute in '%s'", m_filename,
  821.        pBuf);
  822. break;
  823.     case XMLPPlainText:
  824. //Some text.  What do we care?
  825. break;
  826.     case XMLPBadEndTag:
  827. *p = 0;
  828. ERRMSG(m_pMessages,
  829.        "%s: Unexpected end tag '</%s>'", m_filename, tag->m_name);
  830. hResult = HXR_FAIL;
  831. break;
  832.     case XMLPComment:
  833. // A comment, fine.
  834. if(tag != NULL)
  835. {
  836.     //Some kind of comment directive
  837.     XMLAttribute* pAttr = tag->attribute(0);
  838.     if(pAttr &&
  839. pAttr->name)
  840.     {
  841. if(strcasecmp(pAttr->name, "include") == 0)
  842. {
  843.     char* path;
  844.     char* newfile = new char[1024];
  845.     if(!strchr(tag->attribute(0)->value, 
  846.        OS_SEPARATOR_CHAR) &&
  847.        ((path = strrchr(m_filename, OS_SEPARATOR_CHAR))
  848. != NULL))
  849.     {
  850. path++;
  851.                                 if (path - m_filename < 1024)
  852.                                 {
  853.                                     strncpy(newfile, m_filename, path - m_filename);
  854.                                     newfile[path - m_filename] = '';
  855.                                 }
  856. SafeStrCat(newfile, tag->attribute(0)->value, 1024);
  857.     }
  858.     else
  859.     {
  860. SafeStrCpy(newfile, tag->attribute(0)->value, 1024);
  861.     }
  862.     char* filename = m_filename;
  863.     m_filename = NULL;
  864.     Read(newfile, pServRegKey, TRUE);
  865.     delete[] m_filename;
  866.     m_filename = filename;
  867.                             delete[] newfile;
  868. }
  869.     }
  870. }
  871. break;
  872.     case XMLPDirective:
  873. // A directive.  We don't handle any yet.
  874. break;
  875.     case XMLPProcInst:
  876. // A processing Instruction, whee!
  877. break;
  878.     case XMLPTag:
  879.     {
  880. if(Expand(tag, &queue))
  881.     break;
  883. XMLConfigListNode* node = new XMLConfigListNode;
  884. node->m_parent = m_pList->m_parentnode;
  885. node->m_vserver = m_vserver;
  887. if(tag->m_need_close)
  888. {
  889.     if(strcasecmp(tag->m_name, "list") == 0)
  890.     {
  891. const char* name = tag->get_attribute("name");
  892. if(!name)
  893. {
  894.     ERRMSG(m_pMessages,
  895.    "%s: List tag requires a name attribute",
  896.    m_filename);
  897.     // Process anyway, give it a dummy name
  898.     name = "XXXBADLIST";
  899. }
  900. node->m_type = CfgList;
  901. node->m_name = new_string(name);
  902. node->m_num = tag->elem;
  903. m_pList->AddTail(node);
  905. m_pListStack.Push(m_pList);
  906. node->m_pList = new XMLConfigList;
  907. m_pList = node->m_pList;
  908. m_pList->m_parentnode = node;
  909.     }
  910.     else if(strcasecmp(tag->m_name, "server") == 0)
  911.     {
  912. const char* server = tag->get_attribute("number");
  913. if(!server)
  914. {
  915.     ERRMSG(m_pMessages,
  916.    "%s: Server tag requires a number, defaulting to 0",
  917.    m_filename);
  918.     m_vserver = 0;
  919. }
  920. else
  921. {
  922.     char vserver_str[64]; /* Flawfinder: ignore */
  923.     m_vserver = atol(server);
  924.     sprintf(vserver_str, "server%ld", m_vserver); /* Flawfinder: ignore */
  925.     if(m_pRegistry->GetTypeByName(vserver_str) == PT_UNKNOWN)
  926.     {
  927. m_pRegistry->AddComp(vserver_str);
  928. sprintf(vserver_str, "server%ld.config", /* Flawfinder: ignore */
  929. m_vserver);
  930. m_pRegistry->AddComp(vserver_str);
  931.     }
  932. }
  933.     }
  934. }
  935. else if(tag->m_type != XMLEndTag)
  936. {
  937.     const char* name = tag->get_attribute("name");
  938.     const char* value = tag->get_attribute("value");
  939.     if(name && value)
  940.     {
  941. node->m_type  = CfgVar;
  942. node->m_name  = new_string(name);
  943. node->m_value = new_string(value);
  944. node->m_num   = tag->elem;
  945. m_pList->AddTail(node);
  946.     }
  947. }
  948. else
  949. {
  950.     // An End Tag
  951.     if(strcasecmp(tag->m_name, "list") == 0)
  952.     {
  953. m_pList = (XMLConfigList*)m_pListStack.Pop();
  954.     }
  955.     else if(strcasecmp(tag->m_name, "server") == 0)
  956.     {
  957. if(m_vserver < 0)
  958. {
  959.     ERRMSG(m_pMessages,
  960.    "%s: </Server> Tag with no matching <Server>",
  961.    m_filename);
  962. }
  963. else
  964. {
  965.     m_vserver = -1;
  966. }
  967.     }
  968. }
  969. break;
  970.     }
  971. }
  972.     }
  974.     if(hResult == HXR_OK && !bIncludedFile)
  975.     {
  976. StuffRegistry(m_pList);
  977. delete m_pList->m_parentnode;
  978.     }
  980.     if (hResult == HXR_OK && !m_pListStack.IsEmpty())
  981.     {
  982.         ERRMSG(m_pMessages,
  983.    "%s: <List> tag with no matching </List>",
  984.    m_filename);
  985. hResult = HXR_FAIL;
  986.     }
  988.     // cleanup
  989.     if (fp) fclose(fp);
  990.     HX_VECTOR_DELETE(pBuf);
  991.     HX_DELETE(tag);
  993.     return hResult;
  994. }
  996. char*
  997. XMLConfig::XMLConfigListNode::get_registry_name(INT32 vserver)
  998. {
  999.     char* name;
  1000.     if(m_parent)
  1001.     {
  1002. char* parentname = m_parent->get_registry_name(
  1003.     vserver < 0 ? m_vserver : vserver);
  1004. name = new char[strlen(parentname) + strlen(m_name) + 2];
  1005. sprintf(name, "%s.%s", parentname, m_name); /* Flawfinder: ignore */
  1006. delete [] parentname;
  1007. return name;
  1008.     }
  1009.     else
  1010.     {
  1011. if(vserver >= 0)
  1012. {
  1013.     name = new char[26 + strlen(m_name) + 2];
  1014.     sprintf(name, "server%ld.%s", vserver, m_name); /* Flawfinder: ignore */
  1015. }
  1016. else
  1017. {
  1018.     name = new_string(m_name);
  1019. }
  1020. return name;
  1021.     }
  1022. }
  1024. ///XXXPM This func does not correctly handle the original file not
  1025. ///being there.
  1026. HX_RESULT
  1027. XMLConfig::WriteToFile(const char* pKeyName, const char* pFileName)
  1028. {
  1029.     UINT32 ulListsToIgnore = 0;
  1030.     /*
  1031.      * Make sure we have a valid file name to use.
  1032.      */
  1033.     if (!pFileName)
  1034.     {
  1035. return HXR_FAIL;
  1036.     }
  1038.     /*
  1039.      * Copy filename to filename.bak.
  1040.      */
  1041.     char *pNewFileName = new char[strlen(pFileName) + strlen(".bak") + 1];
  1042.     sprintf(pNewFileName, "%s.bak", pFileName); /* Flawfinder: ignore */
  1043.     FILE* fpOld = fopen(pFileName, "r");
  1044.     FILE* fpNew = fopen(pNewFileName, "w");
  1045.     if (!fpNew || !fpOld)
  1046.     {
  1047. HX_VECTOR_DELETE(pNewFileName);
  1048. if (fpNew) fclose(fpNew);
  1049. if (fpOld) fclose(fpOld);
  1050. return HXR_FAIL;
  1051.     }
  1052.     INT32 nBufSize=16384;
  1053.     BYTE* pBuf = new BYTE[nBufSize];
  1054.     int iGot = 0;
  1055.     while (!feof(fpOld))
  1056.     {
  1057. iGot = fread(pBuf, sizeof(char), nBufSize, fpOld);
  1058. if (iGot)
  1059. {
  1060.     fwrite(pBuf, sizeof(char), iGot, fpNew);
  1061. }
  1062.     }
  1063.     fclose(fpNew);
  1064.     fclose(fpOld);
  1066. #ifdef _UNIX
  1067.     chmod(pNewFileName, 0700);
  1068. #endif //UNIX
  1070.     fpNew = fopen(pFileName, "w");
  1071.     fpOld = fopen(pNewFileName, "r");
  1072.     HX_VECTOR_DELETE(pNewFileName);
  1073.     if (!fpNew || !fpOld)
  1074.     {
  1075. if (fpNew) fclose(fpNew);
  1076. if (fpOld) fclose(fpOld);
  1077. return HXR_FAIL;
  1078.     }
  1080.     int l;
  1081.     BOOL filedone = 0;
  1082.     XMLTag*   tag = 0;
  1083.     XMLTag*   wspacetag = 0;
  1084.     CBigByteQueue queue(MAX_TAG_SIZE);
  1085.     XMLParser parser;
  1086.     HX_RESULT hResult = HXR_OK;
  1088.     /*
  1089.      * Files are all aready.  Now we need to build our config levels list.
  1090.      */
  1091.     CHXSimpleList levlist;
  1092.     /*
  1093.      *  Add for level 0.
  1094.      */
  1095.     CHXSimpleList* pNewList = new CHXSimpleList;
  1096.     IHXValues* pValues = 0;
  1098.     _AddPropsToList(pNewList, pKeyName, m_pRegistry);
  1099.     XMLConfigString curr_level;
  1100.     curr_level.AddLevel(pKeyName);
  1102.     while (!filedone && hResult == HXR_OK)
  1103.     {
  1104.         l = fread(pBuf, 1, nBufSize, fpOld);
  1105.         if (l > 0)
  1106.         {
  1107.             if (!queue.EnQueue(pBuf, l))
  1108.             {
  1109.                 if (!queue.Grow(l))
  1110.                 {
  1111.                     ERRMSG(m_pMessages,
  1112.                            "error expanding data structure while parsing");
  1113.                     hResult = HXR_FAIL;
  1114.                 }
  1115.                 if (!queue.EnQueue(pBuf, l))
  1116.                 {
  1117.                     ERRMSG(m_pMessages,
  1118.                            "unknown error while parsing");
  1119.                     hResult = HXR_FAIL;
  1120.                 }
  1121.             }
  1122.         }
  1123.         else
  1124.         {
  1125.             filedone = TRUE;
  1126.         }
  1127.     }
  1129.     UINT32 bytesUsed=0;
  1130.     UINT32 bytesAvail=0;
  1131.     BYTE* p=0;
  1133.     while (hResult == HXR_OK && (bytesAvail = queue.GetQueuedItemCount()) > 0)
  1134.     {
  1135. if (bytesAvail > nBufSize)
  1136.         {
  1137.             HX_VECTOR_DELETE(pBuf);
  1138.             pBuf = new BYTE[bytesAvail];
  1139.             nBufSize = bytesAvail;
  1140.         }
  1141. p = pBuf;
  1143. queue.DeQueue(pBuf, bytesAvail);
  1144. bytesUsed = bytesAvail;
  1146.         HX_DELETE(tag);
  1147. XMLParseResult res = parser.Parse((const char*&)p, bytesAvail, tag);
  1148. queue.EnQueue(p, bytesAvail - (p - pBuf));
  1150. switch(res)
  1151. {
  1152.     case XMLPNoClose:
  1153. // A tag opener was found, but no closer yet.
  1154. if (filedone)
  1155. {
  1156.     pBuf[bytesAvail - 1] = '';
  1157.     if (bytesAvail > MAX_ERROR_CHARS)
  1158.     {
  1159. pBuf[MAX_ERROR_CHARS - 1] = '';
  1160.     }
  1161.     ERRMSG(m_pMessages,
  1162.     "%s: Missing close for tag %s...", m_filename, pBuf);
  1163.     hResult = HXR_FAIL;
  1164. }
  1165. break;
  1166.     case XMLPNoTagType:
  1167. *p = 0;
  1168. ERRMSG(m_pMessages,
  1169.        "%s: Badly formed tag %s", m_filename, pBuf);
  1170. break;
  1171.     case XMLPBadAttribute:
  1172. *p = 0;
  1173. ERRMSG(m_pMessages,
  1174.        "%s: Badly formed attribute in %s", m_filename,
  1175.        pBuf);
  1176. break;
  1177.     case XMLPPlainText:
  1178. /* 
  1179.  * Just plaintext.  Dump this out directly.
  1180.  */
  1181. if (wspacetag)
  1182. {
  1183.     delete wspacetag;
  1184. }
  1185. wspacetag = tag;
  1186. tag = 0;
  1187. /*
  1188. fwrite(tag->m_cur_attribute->value, sizeof(char),
  1189.     strlen(tag->m_cur_attribute->value), fpNew);
  1190.     */
  1191. break;
  1192.     case XMLPBadEndTag:
  1193. *p = 0;
  1194. ERRMSG(m_pMessages,
  1195.        "%s: Unexpected tag %s", m_filename, pBuf);
  1196. break;
  1197.     case XMLPComment:
  1198. /*
  1199.  * Just a comment.  Dump it out.  Comment lives from
  1200.  * p to pBuf.
  1201.  */
  1202. if (wspacetag)
  1203. {
  1204.     fwrite(wspacetag->m_cur_attribute->value, sizeof(char),
  1205. strlen(wspacetag->m_cur_attribute->value), fpNew);
  1206.     delete wspacetag;
  1207.     wspacetag = 0;
  1208. }
  1210. fwrite(pBuf, sizeof(char), p - pBuf, fpNew);
  1211. break;
  1212.     case XMLPDirective:
  1213. // A directive.  We don't handle any yet.
  1214. break;
  1215.     case XMLPProcInst:
  1216.                 /*
  1217.  * Just dump processing instructions as we read them.
  1218.  */
  1219. if (wspacetag)
  1220. {
  1221.     fwrite(wspacetag->m_cur_attribute->value, sizeof(char),
  1222. strlen(wspacetag->m_cur_attribute->value), fpNew);
  1223.     delete wspacetag;
  1224.     wspacetag = 0;
  1225. }
  1227. fwrite(pBuf, sizeof(char), p - pBuf, fpNew);
  1228. break;
  1229.     case XMLPTag:
  1230.     {
  1231. if(Expand(tag, &queue))
  1232.     break;
  1234. if(tag->m_need_close)
  1235. {
  1236.     if(strcasecmp(tag->m_name, "list") == 0)
  1237.     {
  1238. if (ulListsToIgnore)
  1239. {
  1240.     ulListsToIgnore++;
  1241. }
  1242. else
  1243. {
  1244.     const char* name = tag->get_attribute("name");
  1245.     if(!name)
  1246.     {
  1247. ERRMSG(m_pMessages,
  1248.        "%s: List tag requires a name attribute",
  1249.        m_filename);
  1250. // Process anyway, give it a dummy name
  1251. name = "XXXBADLIST";
  1252.     }
  1253.     /*
  1254.      * Remove current tag from list, push current list,
  1255.      * create new list, add next level's props.
  1256.      */
  1257.     _RemovePropFromList(pNewList, name);
  1258.     curr_level.AddLevel(name);
  1259.     if (!_PropExists(&curr_level, m_pRegistry))
  1260.     {
  1261. curr_level.RemoveLevel();
  1262. ulListsToIgnore++;
  1263.     }
  1264.     else
  1265.     {
  1266. levlist.AddHead((void*)pNewList);
  1267. if (wspacetag)
  1268. {
  1269.     fwrite(wspacetag->m_cur_attribute->value, sizeof(char),
  1270. strlen(wspacetag->m_cur_attribute->value), fpNew);
  1271.     delete wspacetag;
  1272.     wspacetag = 0;
  1273. }
  1275. fprintf(fpNew, "<List Name="%s">", name);
  1276. pNewList = new CHXSimpleList;
  1277. _AddPropsToList(pNewList, curr_level.CharStar(), m_pRegistry);
  1278.     }
  1279. }
  1281.     }
  1282. }
  1283. else if(tag->m_type != XMLEndTag)
  1284. {
  1285.     if (!ulListsToIgnore)
  1286.     {
  1287. const char* name = tag->get_attribute("name");
  1288. const char* value = tag->get_attribute("value");
  1289. if (name)
  1290. {
  1291.     curr_level.AddLevel(name);
  1292.     _RemovePropFromList(pNewList, name);
  1293.     /*
  1294.      * Make sure this prop is still set.
  1295.      */
  1296.     if (_PropExists(&curr_level, m_pRegistry))
  1297.     {
  1298. if (wspacetag)
  1299. {
  1300.     fwrite(wspacetag->m_cur_attribute->value, sizeof(char),
  1301. strlen(wspacetag->m_cur_attribute->value), fpNew);
  1302.     delete wspacetag;
  1303.     wspacetag = 0;
  1304. }
  1306. char* p = _GetPropValueString(curr_level.CharStar(), m_pRegistry);
  1308. if (p)
  1309. {
  1310.     fprintf(fpNew, "<Var %s="%s"/>",
  1311. name,
  1312. p);
  1313.     delete[] p;
  1314. }
  1315.     }
  1316.     curr_level.RemoveLevel();
  1317. }
  1318.     }
  1319. }
  1320. else
  1321. {
  1322.     // An End Tag
  1323.     if(strcasecmp(tag->m_name, "list") == 0)
  1324.     {
  1325. if (ulListsToIgnore)
  1326. {
  1327.     ulListsToIgnore --;
  1328. }
  1329. else
  1330. {
  1331.     /*
  1332.      * Need to add the stuff at this level that was
  1333.      * was not in the config file.
  1334.      */
  1335.     if (pNewList->GetCount() == 0)
  1336.     {
  1337. if (wspacetag)
  1338. {
  1339.     fwrite(wspacetag->m_cur_attribute->value, sizeof(char),
  1340. strlen(wspacetag->m_cur_attribute->value), fpNew);
  1341. }
  1342.     }
  1343.     else
  1344.     {
  1345. fprintf(fpNew, "n");
  1346. AppendPropsToFile(fpNew, curr_level, pNewList,
  1347.     4, m_pRegistry, pKeyName);
  1348. _IndentFile(fpNew, 4, curr_level, pKeyName);
  1349.     }
  1350.     delete wspacetag;
  1351.     wspacetag = 0;
  1353.     fprintf(fpNew, "</List>");
  1354.     curr_level.RemoveLevel();
  1355.     delete pNewList;
  1356.     pNewList = (CHXSimpleList*)levlist.RemoveHead();
  1357. }
  1358.     }
  1359. }
  1360. break;
  1361.     }
  1362. }
  1364. // Give up if we've lost all hope
  1365. if (HXR_OK != hResult)
  1366. {
  1367.     break;
  1368. }
  1369.     }
  1370.     if (hResult == HXR_OK && wspacetag)
  1371.     {
  1372. fwrite(wspacetag->m_cur_attribute->value, sizeof(char),
  1373.     strlen(wspacetag->m_cur_attribute->value), fpNew);
  1374. delete wspacetag;
  1375. wspacetag = 0;
  1376.     }
  1378.     /*
  1379.      * Ok, done with the whole file. Make sure that all of the base level stuff
  1380.      * gets added.
  1381.      */
  1382.      //XXXPM Calculate this later.
  1383.     if (hResult == HXR_OK)
  1384.     {
  1385.         int indent = 4;
  1386.         AppendPropsToFile(fpNew, curr_level, pNewList, indent, m_pRegistry, pKeyName);
  1387.     }
  1389.     // cleanup
  1390.     if (fpNew) fclose(fpNew);
  1391.     if (fpOld) fclose(fpOld);
  1392.     HX_DELETE(pNewList);
  1393.     HX_VECTOR_DELETE(pBuf);
  1394.     HX_DELETE(tag);
  1396.     return hResult;
  1397. }
  1400. void
  1401. XMLConfig::_AddPropsToList(CHXSimpleList* pList, const char* pName,
  1402.   IHXRegistry2* preg)
  1403. {
  1404.     IHXValues* pValues = 0;
  1405.     UINT32 ul;
  1406.     const char* pPropName;
  1407.     preg->GetPropListByName(pName, pValues);
  1409.     if (pValues)
  1410.     {
  1411. if (HXR_OK == pValues->GetFirstPropertyULONG32(pPropName, ul))
  1412. {
  1413.     XMLPropInfo* pInfo = new XMLPropInfo;
  1414.     pInfo->m_pName = new char[strlen(pPropName) + 1 - strlen(pName)];
  1415.     strcpy(pInfo->m_pName, &(pPropName[strlen(pName) + 1])); /* Flawfinder: ignore */
  1416.     pInfo->m_Type = preg->GetTypeByName(pPropName);
  1417.     pList->AddHead((void*)pInfo);
  1419.     while (HXR_OK == pValues->GetNextPropertyULONG32(pPropName, ul))
  1420.     {
  1421. XMLPropInfo* pInfo = new XMLPropInfo;
  1422. pInfo->m_pName = new char[strlen(pPropName) + 1 - strlen(pName)];
  1423. strcpy(pInfo->m_pName, &(pPropName[strlen(pName) + 1]));
  1424. pInfo->m_Type = preg->GetTypeByName(pPropName);
  1425. pList->AddHead((void*)pInfo);
  1426.     }
  1427. }
  1428. pValues->Release();
  1429.     }
  1430. }
  1432. void
  1433. XMLConfig::_RemovePropFromList(CHXSimpleList* pList, const char* pName)
  1434. {
  1435.     LISTPOSITION pos;
  1436.     pos = pList->GetHeadPosition();
  1438.     XMLPropInfo* pProp;
  1440.     
  1441.     while (pos)
  1442.     {
  1443. pProp = (XMLPropInfo*)pList->GetAt(pos);
  1444. if (!pProp)
  1445. {
  1446.     return;
  1447. }
  1448. if (!strcasecmp(pProp->m_pName, pName))
  1449. {
  1450.     pList->RemoveAt(pos);
  1451.     delete pProp;
  1452.     return;
  1453. }
  1454. pList->GetNext(pos);
  1456.     }
  1457. }
  1459. char*
  1460. XMLConfig::_GetPropValueString(const char* pName, IHXRegistry2* pReg)
  1461. {
  1462.     int vartype;
  1463.     IHXBuffer* pBuffer;
  1464.     INT32 l;
  1465.     char* ret;
  1467.     vartype = pReg->GetTypeByName(pName);
  1468.     if(vartype == PT_INTEGER)
  1469.     {
  1470. if(HXR_OK == pReg->GetIntByName(pName, l))
  1471. {
  1472.     char num[32]; /* Flawfinder: ignore */
  1473.     sprintf(num, "%d", l); /* Flawfinder: ignore */
  1474.     ret = new char[strlen(num) + 1];
  1475.     strcpy(ret, num); /* Flawfinder: ignore */
  1476.     return ret;
  1477. }
  1478. else
  1479. {
  1480.     return 0;
  1481. }
  1482.     }
  1483.     else if(vartype == PT_STRING)
  1484.     {
  1485. if(HXR_OK == pReg->GetStrByName(pName,
  1486.     pBuffer) && pBuffer)
  1487. {
  1488.     ret = new char[pBuffer->GetSize()+1];
  1489.     strcpy(ret, (const char*)pBuffer->GetBuffer()); /* Flawfinder: ignore */
  1490.     pBuffer->Release();
  1491.     return ret;
  1492. }
  1493. else
  1494. {
  1495.     return 0;
  1496. }
  1497.     }
  1498.     return 0;
  1499. }
  1501. void
  1502. XMLConfig::_CleanList(CHXSimpleList* pList)
  1503. {
  1504.     XMLPropInfo* pInfo;
  1505.     while (!pList->IsEmpty())
  1506.     {
  1507. pInfo = (XMLPropInfo*)pList->RemoveHead();
  1508. delete pInfo;
  1509.     }
  1510. }
  1512. void
  1513. XMLConfig::AppendPropsToFile(FILE* fp, XMLConfigString level,
  1514.     CHXSimpleList* pList, int indent_per_level,
  1515.     IHXRegistry2* hxreg, const char* pBase)
  1516. {
  1517.     XMLPropInfo* pInfo = 0;
  1518.     while (!pList->IsEmpty())
  1519.     {
  1520. pInfo = (XMLPropInfo*)pList->RemoveHead();
  1521. level.AddLevel(pInfo->m_pName);
  1522. _AppendPropToFile(fp, level, indent_per_level, hxreg, pBase);
  1523. level.RemoveLevel();
  1524. delete pInfo;
  1525.     }
  1526. }
  1528. void
  1529. XMLConfig::_IndentFile(FILE* fp, int indent_per_level,
  1530.  XMLConfigString level,
  1531.  const char* pBase)
  1532. {
  1533.     int dots_to_ignore = 1;
  1534.     INT32 i;
  1535.     const char* pc;
  1536.     pc = pBase;
  1537.     while (*pc)
  1538.     {
  1539. if (*pc == '.')
  1540. {
  1541.     dots_to_ignore ++;
  1542. }
  1543. pc++;
  1544.     }
  1545.     pc = level.CharStar();
  1546.     while (*pc)
  1547.     {
  1548. if (*pc == '.')
  1549. {
  1550.     if (dots_to_ignore)
  1551.     {
  1552. dots_to_ignore--;
  1553.     }
  1554.     else
  1555.     {
  1556. for (i = 0; i < indent_per_level; i++)
  1557. {
  1558.     fprintf(fp, " ");
  1559. }
  1560.     }
  1561. }
  1562. pc ++;
  1563.     }
  1564. }
  1566. void
  1567. XMLConfig::_AppendPropToFile(FILE* fp, XMLConfigString level,
  1568.      int indent_per_level,
  1569.      IHXRegistry2* hxreg,
  1570.      const char* pBase)
  1571. {
  1572.     /*
  1573.      * Indent a proper amount.
  1574.      */
  1575.     INT32 i;
  1576.     IHXBuffer* pBuf = 0;
  1578.     _IndentFile(fp, indent_per_level, level, pBase);
  1580.     HXPropType type = hxreg->GetTypeByName(level.CharStar());
  1581.     switch (type)
  1582.     {
  1583.     case PT_COMPOSITE:
  1584. fprintf(fp, "<List Name="%s">n", level.Top());
  1585. IHXValues* pValues;
  1586. if (HXR_OK == hxreg->GetPropListByName(level.CharStar(),
  1587.     pValues) && pValues)
  1588. {
  1589.     HX_RESULT res;
  1590.     UINT32 ul;
  1591.     const char* pName;
  1592.     res = pValues->GetFirstPropertyULONG32(pName, ul);
  1593.     while (res == HXR_OK)
  1594.     {
  1595. const char* pc = pName + strlen(pName);
  1596. while (pc > pName)
  1597. {
  1598.     pc--;
  1599.     if (*pc == '.')
  1600.     {
  1601. pc++;
  1602. level.AddLevel(pc);
  1603. _AppendPropToFile(fp, level, indent_per_level, hxreg, pBase);
  1604. level.RemoveLevel();
  1605. res = pValues->GetNextPropertyULONG32(pName, ul);
  1606. break;
  1607.     }
  1608. }
  1609.     }
  1610.     pValues->Release();
  1611. }
  1612. _IndentFile(fp, indent_per_level, level, pBase);
  1613. fprintf(fp, "</List>n");
  1614. break;
  1616.     case PT_INTEGER:
  1617. if (HXR_OK == hxreg->GetIntByName(level.CharStar(), i))
  1618. {
  1619.     fprintf(fp, "<Var %s="%ld"/>n", level.Top(),
  1620. i);
  1621. }
  1622. break;
  1624.     case PT_STRING:
  1625. if (HXR_OK == hxreg->GetStrByName(level.CharStar(), pBuf)
  1626.     && pBuf)
  1627. {
  1628.     fprintf(fp, "<Var %s="%s"/>n", level.Top(),
  1629. (const char*)pBuf->GetBuffer());
  1630.     pBuf->Release();
  1631.     pBuf = 0;
  1632. }
  1633. break;
  1634.     }
  1635. }
  1637. int
  1638. XMLConfig::_PropExists(XMLConfigString* p, IHXRegistry2* preg)
  1639. {
  1640.     return (preg->GetPropStatusByName(p->CharStar()) == HXR_OK) ? TRUE : FALSE;
  1641. }
  1643. /*
  1644.  * IHXRegConfig::WriteKey
  1645.  */
  1646. STDMETHODIMP
  1647. XMLConfig::WriteKey(const char* pKeyName)
  1648. {
  1649.     /*
  1650.      * If there is a filename then we got it from a file.
  1651.      */
  1652.     if (m_filename)
  1653.     {
  1654. WriteToFile(pKeyName, m_filename);
  1655. return HXR_OK;
  1656.     }
  1658.     HX_ASSERT(0);
  1659.     return HXR_FAIL;
  1660. }
  1662. HX_RESULT
  1663. XMLConfig::Reconfigure(IHXReconfigServerResponse* pResp)
  1664. {
  1665.     if (m_pReconfigureResponse)
  1666.     {
  1667. return HXR_UNEXPECTED;
  1668.     }
  1669.     m_pReconfigureResponse = pResp;
  1670.     m_pReconfigureResponse->AddRef();
  1672.     /*
  1673.      * If they started from a config file, then reload
  1674.      * from the config file.
  1675.      */
  1676.     if (m_filename)
  1677.     {
  1678. return Reconfigure(m_filename);
  1679.     }
  1681.     /*
  1682.      * If we got here there was a booboo
  1683.      */
  1684.     m_pReconfigureResponse->ReconfigServerDone(HXR_OK, 0, 0);
  1685.     m_pReconfigureResponse->Release();
  1686.     m_pReconfigureResponse = 0;
  1688.     return HXR_OK;
  1689. }
  1691. HX_RESULT
  1692. XMLConfig::Reconfigure(const char* pFileName)
  1693. {
  1694.     if (!pFileName)
  1695.     {
  1696. return HXR_FAIL;
  1697.     }
  1699.     FILE* fp = fopen(pFileName, "r");
  1700.     if (!fp)
  1701.     {
  1702. return HXR_FAIL;
  1703.     }
  1705.     /*
  1706.      * Pretend that there is one outstanding just to keep
  1707.      * the done methods from getting called, seeing a 0,
  1708.      * and sending the response until the end of this 
  1709.      * func.
  1710.      */
  1711.     m_ActiveSetsOutstanding++;
  1713.     const char* pKeyName = "config";
  1714.     int l = 0;
  1715.     BOOL filedone = 0;
  1716.     XMLTag*   tag = 0;
  1717.     CBigByteQueue queue(MAX_TAG_SIZE);
  1718.     XMLParser parser;
  1719.     HX_RESULT hResult = HXR_OK;
  1721.     /*
  1722.      * Files are all aready.  Now we need to build our config levels list.
  1723.      */
  1724.     CHXSimpleList levlist;
  1725.     /*
  1726.      *  Add for level 0.
  1727.      */
  1728.     CHXSimpleList* pNewList = new CHXSimpleList;
  1729.     IHXValues* pValues = 0;
  1731.     _AddPropsToList(pNewList, pKeyName, m_pRegistry);
  1732.     XMLConfigString curr_level;
  1733.     curr_level.AddLevel(pKeyName);
  1735.     // read the config file into the byte queue
  1736.     INT32 nBufSize = 16384;
  1737.     BYTE* pBuf = new BYTE[nBufSize];
  1738.     while (!filedone && hResult == HXR_OK)
  1739.     {
  1740.         l = fread(pBuf, 1, nBufSize, fp);
  1741.         if (l > 0)
  1742.         {
  1743.             if (!queue.EnQueue(pBuf, l))
  1744.             {
  1745.                 if (!queue.Grow(l))
  1746.                 {
  1747.                     ERRMSG(m_pMessages,
  1748.                            "error expanding data structure while parsing %s",
  1749.                            pFileName);
  1750.                     hResult = HXR_FAIL;
  1751.                 }
  1752.                 if (!queue.EnQueue(pBuf, l))
  1753.                 {
  1754.                     ERRMSG(m_pMessages,
  1755.                            "unknown error while parsing %s",
  1756.                            pFileName);
  1757.                     hResult = HXR_FAIL;
  1758.                 }
  1759.             }
  1760. }
  1761. else
  1762. {
  1763.             filedone = TRUE;
  1764. }
  1765.     }
  1767.     UINT32 bytesUsed=0;
  1768.     UINT32 bytesAvail=0;
  1769.     BYTE* p=0;
  1770.     while (hResult == HXR_OK && (bytesAvail = queue.GetQueuedItemCount()) > 0)
  1771.     {
  1772. if (bytesAvail > nBufSize)
  1773.         {
  1774.             HX_VECTOR_DELETE(pBuf);
  1775.             pBuf = new BYTE[bytesAvail];
  1776.             nBufSize = bytesAvail;
  1777.         }
  1778. p = pBuf;
  1780. queue.DeQueue(pBuf, bytesAvail);
  1781. bytesUsed = bytesAvail;
  1783.         HX_DELETE(tag);
  1784. XMLParseResult res = parser.Parse((const char*&)p, bytesAvail, tag);
  1785. queue.EnQueue(p, bytesAvail - (p - pBuf));
  1787. switch(res)
  1788. {
  1789.     case XMLPNoClose:
  1790. // A tag opener was found, but no closer yet.
  1791. if (filedone)
  1792. {
  1793.     pBuf[bytesAvail - 1] = '';
  1794.     if (bytesAvail > MAX_ERROR_CHARS)
  1795.     {
  1796. pBuf[MAX_ERROR_CHARS - 1] = '';
  1797.     }
  1798.     ERRMSG(m_pMessages,
  1799.     "%s: Missing close for tag %s...", m_filename, pBuf);
  1800.     hResult = HXR_FAIL;
  1801. }
  1802. break;
  1803.     case XMLPNoTagType:
  1804. *p = 0;
  1805. ERRMSG(m_pMessages,
  1806.        "%s: Badly formed tag %s", m_filename, pBuf);
  1807. break;
  1808.     case XMLPBadAttribute:
  1809. *p = 0;
  1810. ERRMSG(m_pMessages,
  1811.        "%s: Badly formed attribute in %s", m_filename,
  1812.        pBuf);
  1813. break;
  1814.     case XMLPPlainText:
  1815. break;
  1816.     case XMLPBadEndTag:
  1817. *p = 0;
  1818. ERRMSG(m_pMessages,
  1819.        "%s: Unexpected tag %s", m_filename, pBuf);
  1820. break;
  1821.     case XMLPComment:
  1822. break;
  1823.     case XMLPDirective:
  1824. // A directive.  We don't handle any yet.
  1825. break;
  1826.     case XMLPProcInst:
  1827. // A processing Instruction, whee!
  1828. break;
  1829.     case XMLPTag:
  1830.     {
  1831. if(Expand(tag, &queue))
  1832.     break;
  1834. if(tag->m_need_close)
  1835. {
  1836.     if(strcasecmp(tag->m_name, "list") == 0)
  1837.     {
  1838. const char* name = tag->get_attribute("name");
  1839. if(!name)
  1840. {
  1841.     ERRMSG(m_pMessages,
  1842.    "%s: List tag requires a name attribute",
  1843.    m_filename);
  1844.     // Process anyway, give it a dummy name
  1845.     name = "XXXBADLIST";
  1846. }
  1847. /*
  1848.  * Remove current tag from list, push current list,
  1849.  * create new list, add next level's props.
  1850.  */
  1851. _RemovePropFromList(pNewList, name);
  1852. curr_level.AddLevel(name);
  1853. levlist.AddHead((void*)pNewList);
  1854. pNewList = new CHXSimpleList;
  1855. _AddPropsToList(pNewList, curr_level.CharStar(), m_pRegistry);
  1857.     }
  1858. }
  1859. else if(tag->m_type != XMLEndTag)
  1860. {
  1861.     const char* name = tag->get_attribute("name");
  1862.     const char* value = tag->get_attribute("value");
  1863.     if (name)
  1864.     {
  1865. curr_level.AddLevel(name);
  1866. _RemovePropFromList(pNewList, name);
  1867. /*
  1868.  * Here we need to try to set that value.
  1869.  */
  1870. _ResetProp(&curr_level, value, m_pRegistry);
  1871. curr_level.RemoveLevel();
  1872.     }
  1873. }
  1874. else
  1875. {
  1876.     // An End Tag
  1878.     /*
  1879.      * Here we need to try to delete everything that
  1880.      * was not in the file.
  1881.      */
  1882.     if(strcasecmp(tag->m_name, "list") == 0)
  1883.     {
  1884. _HandlePropsRemovedFromFile(
  1885.     &curr_level, pNewList,
  1886.     m_pRegistry);
  1887. curr_level.RemoveLevel();
  1888. delete pNewList;
  1889. pNewList = (CHXSimpleList*)levlist.RemoveHead();
  1890.     }
  1891. }
  1892. break;
  1893.     }
  1894. }
  1895.     }
  1896.     
  1897.     _HandlePropsRemovedFromFile(&curr_level, pNewList, m_pRegistry);
  1899.     // cleanup
  1900.     if (fp) fclose(fp);
  1901.     HX_DELETE(tag);
  1902.     HX_DELETE(pNewList);
  1903.     HX_VECTOR_DELETE(pBuf);
  1905.     // send reconfig response
  1906.     m_ActiveSetsOutstanding--;
  1907.     MaybeSendReconfigResponse();
  1909.     return hResult;
  1910. }
  1912. #ifdef _WIN32
  1913. HX_RESULT
  1914. XMLConfig::ReconfigureFromReg(const char* pKeyname)
  1915. {
  1916.     HX_ASSERT(pKeyname && strlen(pKeyname));
  1918.     /* 
  1919.      * This should be a duplication of the above loop just using
  1920.      * the registry instead of a file.
  1921.      */
  1923.     /*
  1924.      * Pretend that there is one outstanding just to keep
  1925.      * the done methods from getting called, seeing a 0,
  1926.      * and sending the response until the end of this 
  1927.      * func.
  1928.      */
  1929.     m_ActiveSetsOutstanding++;
  1931.     CHXSimpleList levlist;
  1932.     CHXSimpleList indexlist;
  1933.     int curr_index = 0;
  1934.     UINT32 ulBufLen = 512;
  1935.     UINT32 ulRealBufLen = 512;
  1936.     char* pRegBuf = new char[512];
  1938.     UINT32 ulBufLen2 = 256;
  1939.     UINT32 ulRealBufLen2 = 256;
  1940.     char* pRegBuf2 = new char[256];
  1942.     UINT32 ulBufLen3 = 256;
  1943.     UINT32 ulRealBufLen3 = 256;
  1944.     char* pRegBuf3 = new char[256];
  1945.     FILETIME msbs;
  1946.     /*
  1947.      *  Add for level 0.
  1948.      */
  1949.     CHXSimpleList* pNewList = new CHXSimpleList;
  1950.     IHXValues* pValues = 0;
  1952.     _AddPropsToList(pNewList, "Config", m_pRegistry);
  1953.     XMLConfigString curr_level;
  1954.     curr_level.AddLevel("Config");
  1956.     char* pRegBase = new char[512];
  1957.     memset(pRegBase, 0, 512);
  1958.     SafeSprintf(pRegBase, 512, "Software\RealNetworks\%s\%d.%d\",
  1959.             m_szServerversion, m_ulMajor, m_ulMinor);
  1960.     UINT32 ulRegBase = strlen(pRegBase) + 1;
  1962.     HKEY hKey=0;
  1963.     LONG ret=0;
  1964.     BOOL bDone = 0;
  1965.     char* pc=0;
  1966.     /*
  1967.      * While we are not done...
  1968.      */
  1969.     while (!bDone)
  1970.     {
  1971. pc = pRegBase + ulRegBase;
  1972. SafeStrCpy(pc, curr_level.CharStar(), 512-ulRegBase);
  1973. while (pc < pRegBase + 512 && *pc)
  1974. {
  1975.     if (*pc == '.')
  1976.     {
  1977. *pc = '\';
  1978.     }
  1979.     pc++;
  1980. }
  1981. ret = RegOpenKeyEx(HKEY_CLASSES_ROOT, pRegBase, 0, KEY_READ, &hKey);
  1982. if (ret != ERROR_SUCCESS)
  1983. {
  1984.     //XXXPM fix this
  1985.     HX_ASSERT(0);
  1986. }
  1988. ulBufLen = ulRealBufLen;
  1989. //XXXPM handle buffer too small
  1990. ret = RegEnumKeyEx(hKey, curr_index,
  1991.     pRegBuf, &ulBufLen, 0, NULL, NULL, &msbs);
  1992. curr_index++;
  1993. /*
  1994.  * If it is a composite...
  1995.  */
  1996. if (ret == ERROR_SUCCESS)
  1997. {
  1998.     const char* name = pRegBuf;
  1999.     _RemovePropFromList(pNewList, name);
  2000.     curr_level.AddLevel(name);
  2001.     levlist.AddHead((void*)pNewList);
  2002.     indexlist.AddHead((void*)curr_index);
  2003.     curr_index = 0;
  2004.     pNewList = new CHXSimpleList;
  2005.     _AddPropsToList(pNewList, curr_level.CharStar(), m_pRegistry);
  2006. }
  2007. /*
  2008.  * It is a non composite value, so we need to get that value.
  2009.  */
  2010. else
  2011. {
  2012.     const char* name = pRegBuf;
  2013.     const char* value = 0;
  2014.     ulBufLen2 = ulRealBufLen2;
  2015.     ulBufLen3 = ulRealBufLen3;
  2016.     DWORD dwType;
  2017.     //XXXPM handle buffer too small
  2019.     ret = RegEnumValue(hKey, 0, pRegBuf2, &ulBufLen2, 0, &dwType, 
  2020.                (unsigned char*)pRegBuf3, &ulBufLen3);
  2021.     if (ret == ERROR_SUCCESS)
  2022.     {
  2023. value = pRegBuf3;
  2024. _ResetProp(&curr_level, value, m_pRegistry);
  2025. curr_level.RemoveLevel();
  2026. delete pNewList;
  2027. pNewList = (CHXSimpleList*)levlist.RemoveHead();
  2028. curr_index = (int)indexlist.RemoveHead();
  2029.     }
  2030.     else
  2031.     {
  2032. /*
  2033.  * Closing a composite.
  2034.  */
  2035. _HandlePropsRemovedFromFile(&curr_level, pNewList, m_pRegistry);
  2036. curr_level.RemoveLevel();
  2037. delete pNewList;
  2038. if (!levlist.IsEmpty())
  2039. {
  2040.     pNewList = (CHXSimpleList*)levlist.RemoveHead();
  2041.     curr_index = (int)indexlist.RemoveHead();
  2042. }
  2043. else
  2044. {
  2045.     pNewList = 0;
  2046.     bDone = 1;
  2047. }
  2048.     }
  2049. }
  2050. RegCloseKey(hKey);
  2052.     }
  2054.     delete[] pRegBase;
  2055.     delete[] pRegBuf;
  2056.     delete[] pRegBuf2;
  2057.     delete[] pRegBuf3;
  2059.     m_ActiveSetsOutstanding--;
  2060.     MaybeSendReconfigResponse();
  2062.     return HXR_OK;
  2063. }
  2064. #endif
  2066. HX_RESULT
  2067. XMLConfig::_ResetProp(XMLConfigString* plevel, const char* value, IHXRegistry2* preg)
  2068. {
  2069.     HX_RESULT res = HXR_FAIL;
  2070.     IHXActiveRegistry* pActiveReg = 0;
  2071.     LONG32 ulCurrent;
  2072.     LONG32 ulNew;
  2073.     preg->QueryInterface(IID_IHXActiveRegistry,
  2074. (void**)&pActiveReg);
  2075.     if (pActiveReg == 0)
  2076.     {
  2077. return HXR_FAIL;
  2078.     }
  2080.     /*
  2081.      * If the prop exists, then figure out the type.
  2082.      */
  2083.     if (_PropExists(plevel, preg))
  2084.     {
  2085. HXPropType type;
  2086. type = preg->GetTypeByName(plevel->CharStar());
  2087. switch (type)
  2088. {
  2089. case PT_INTEGER:
  2090.     ulCurrent = 0;
  2091.     ulNew = atoi(value);
  2093.     /*
  2094.      * If it is an int and we are not changing its value, then say ok and
  2095.      * exit.
  2096.      */
  2097.     preg->GetIntByName(plevel->CharStar(),
  2098. ulCurrent);
  2099.     if (ulCurrent == ulNew)
  2100.     {
  2101. res = HXR_OK;
  2102. goto done;
  2103.     }
  2105.     /*
  2106.      * Try to set it by hand first.
  2107.      */
  2108.     res = preg->SetIntByName(plevel->CharStar(),
  2109. atoi(value));
  2111.     /*
  2112.      * If it failed because it was active, then use the active reg
  2113.      * to set it and add it to our outstanding actives count.
  2114.      */
  2115.     if (res == HXR_PROP_ACTIVE)
  2116.     {
  2117. m_ActiveSetsOutstanding ++;
  2118. res = pActiveReg->SetActiveInt(plevel->CharStar(),
  2119.     ulNew, this);
  2120. if (res != HXR_OK)
  2121. {
  2122.     m_ActiveSetsOutstanding --;
  2123. }
  2124.     }
  2125.     /*
  2126.      * res should be set for good by now.
  2127.      */
  2128.     goto done;
  2129.     
  2130. case PT_STRING:
  2131.     IHXBuffer* pCurrent = 0;
  2133.     /*
  2134.      * See if we are changing this string value at all.
  2135.      */
  2136.     preg->GetStrByName(plevel->CharStar(),
  2137. pCurrent);
  2138.     if (pCurrent)
  2139.     {
  2140. /*
  2141.  * If we are not changing it at all then say ok and exit.
  2142.  */
  2143. if (!strcmp((const char*)pCurrent->GetBuffer(),
  2144.     value))
  2145. {
  2146.     pCurrent->Release();
  2147.     res = HXR_OK;
  2148.     goto done;
  2149. }
  2150. pCurrent->Release();
  2151.     }
  2153.     /*
  2154.      * We are changing it so get a new buffer and set it.
  2155.      */
  2156.     IHXBuffer* pBuffer = new CHXBuffer();
  2157.             pBuffer->AddRef();
  2158.     pBuffer->Set((const unsigned char*)value, strlen(value) + 1);
  2160.     res = preg->SetStrByName(plevel->CharStar(),
  2161. pBuffer);
  2163.     /*
  2164.      * If we failed to set it because it is active, then use the
  2165.      * active registry and add to our outstanding actives count.
  2166.      */
  2167.     if (res == HXR_PROP_ACTIVE)
  2168.     {
  2169. m_ActiveSetsOutstanding++;
  2170. res = pActiveReg->SetActiveStr(plevel->CharStar(),
  2171.     pBuffer, this);
  2172. if (res != HXR_OK)
  2173. {
  2174.     m_ActiveSetsOutstanding --;
  2175. }
  2176.     }
  2177.     pBuffer->Release();
  2178.     goto done;
  2180. }
  2182.     }
  2183.     else
  2184.     {
  2185. /*
  2186.  * This is the case where this prop was not already there,
  2187.  * so figure out the type from the data.
  2188.  */
  2189. BOOL bIsNum = TRUE;
  2190. const char* pc = value;
  2191. while(*pc)
  2192. {
  2193.     if (*pc < '0' || *pc > '9')
  2194.     {
  2195. bIsNum = FALSE;
  2196. break;
  2197.     }
  2198.     pc++;
  2199. }
  2200. if (pc == value)
  2201. {
  2202.     bIsNum = FALSE;
  2203. }
  2205. if (bIsNum)
  2206. {
  2207.     /*
  2208.      * It should be an Integer type so attempt to Set it through the
  2209.      * active reg.  (This acts like an add through the active reg.  Could
  2210.      * have tried to add it by hand first, but didn't.
  2211.      */
  2212.     m_ActiveSetsOutstanding++;
  2213.     res = pActiveReg->SetActiveInt(plevel->CharStar(),
  2214. atoi(value), this);
  2215.     if (res != HXR_OK)
  2216.     {
  2217. m_ActiveSetsOutstanding--;
  2218.     }
  2220. }
  2221. else
  2222. {
  2223.     /*
  2224.      * It should be a string type.  We will just try to do it through active.
  2225.      * (see last comment).
  2226.      */
  2227.     IHXBuffer* pBuffer = new CHXBuffer();
  2228.             pBuffer->AddRef();
  2229.     pBuffer->Set((const unsigned char*)value,
  2230. strlen(value) + 1);
  2231.     m_ActiveSetsOutstanding++;
  2232.     res = pActiveReg->SetActiveStr(plevel->CharStar(),
  2233. pBuffer, this);
  2234.     if (res != HXR_OK)
  2235.     {
  2236. m_ActiveSetsOutstanding--;
  2237.     }
  2238.     pBuffer->Release();
  2239. }
  2240.     }
  2241. done:;
  2242.     pActiveReg->Release();
  2243.     return res;
  2244. }
  2246. /************************************************************************
  2247.  * IHXActivePropUserResponse stuff.
  2248.  *
  2249.  * Called with status result on completion of set request.
  2250.  */
  2251. STDMETHODIMP
  2252. XMLConfig::SetActiveIntDone(HX_RESULT res,
  2253. const char* pName,
  2254. UINT32 ul,
  2255. IHXBuffer* pInfo[],
  2256. UINT32 ulNumInfo)
  2257. {
  2258.     m_ActiveSetsOutstanding--;
  2259.     MaybeSendReconfigResponse();
  2260.     return HXR_OK;
  2261. }
  2263. STDMETHODIMP
  2264. XMLConfig::SetActiveStrDone(HX_RESULT res,
  2265. const char* pName,
  2266. IHXBuffer* pBuffer,
  2267. IHXBuffer* pInfo[],
  2268. UINT32 ulNumInfo)
  2269. {
  2270.     m_ActiveSetsOutstanding--;
  2271.     MaybeSendReconfigResponse();
  2272.     return HXR_OK;
  2273. }
  2275. STDMETHODIMP
  2276. XMLConfig::SetActiveBufDone(HX_RESULT res,
  2277. const char* pName,
  2278. IHXBuffer* pBuffer,
  2279. IHXBuffer* pInfo[],
  2280. UINT32 ulNumInfo)
  2281. {
  2282.     m_ActiveSetsOutstanding--;
  2283.     MaybeSendReconfigResponse();
  2284.     return HXR_OK;
  2285. }
  2287. STDMETHODIMP
  2288. XMLConfig::DeleteActivePropDone(HX_RESULT res,
  2289. const char* pName,
  2290. IHXBuffer* pInfo[],
  2291. UINT32 ulNumInfo)
  2292. {
  2293.     m_ActiveSetsOutstanding--;
  2294.     MaybeSendReconfigResponse();
  2295.     return HXR_OK;
  2296. }
  2298. void
  2299. XMLConfig::MaybeSendReconfigResponse()
  2300. {
  2301.     /*
  2302.      * If everything has not happened yet,
  2303.      * then bail.
  2304.      */
  2305.     if (m_ActiveSetsOutstanding)
  2306.     {
  2307. return;
  2308.     }
  2310.     m_pReconfigureResponse->ReconfigServerDone(HXR_OK,
  2311. 0, 0);
  2312.     m_pReconfigureResponse->Release();
  2313.     m_pReconfigureResponse = 0;
  2314. }
  2316. void
  2317. XMLConfig::_HandlePropsRemovedFromFile(XMLConfigString* plevel,
  2318.        CHXSimpleList* pList,
  2319.        IHXRegistry2* preg)
  2320. {
  2321.     XMLPropInfo* pInfo;
  2322.     while (!pList->IsEmpty())
  2323.     {
  2324. pInfo = (XMLPropInfo*)pList->RemoveHead();
  2325. plevel->AddLevel(pInfo->m_pName);
  2326. switch (pInfo->m_Type)
  2327. {
  2328. case PT_STRING:
  2329.     {
  2330. IHXBuffer* pval;
  2331. pval = _GetDefaultValString(
  2332.     plevel->CharStar(), preg);
  2333. if (!pval)
  2334. {
  2335.     if (!preg->DeleteByName(
  2336. plevel->CharStar()))
  2337.     {
  2338. IHXActiveRegistry* pActiveReg = 0;
  2339. preg->QueryInterface(IID_IHXActiveRegistry,
  2340.     (void**)&pActiveReg);
  2341. if (pActiveReg)
  2342. {
  2343.     m_ActiveSetsOutstanding++;
  2344.     if (HXR_OK != pActiveReg->DeleteActiveProp(
  2345. plevel->CharStar(),
  2346. this))
  2347.     {
  2348. m_ActiveSetsOutstanding--;
  2349.     }
  2350.     pActiveReg->Release();
  2351. }
  2352.     }
  2353. }
  2354. else
  2355. {
  2356.     if (HXR_PROP_ACTIVE == preg->SetStrByName(plevel->CharStar(),
  2357. pval))
  2358.     {
  2359. IHXActiveRegistry* pActiveReg = 0;
  2360. preg->QueryInterface(IID_IHXActiveRegistry,
  2361.     (void**)&pActiveReg);
  2362. if (pActiveReg)
  2363. {
  2364.     m_ActiveSetsOutstanding++;
  2365.     if (HXR_OK != pActiveReg->SetActiveStr(
  2366. plevel->CharStar(), pval,
  2367. this))
  2368.     {
  2369. m_ActiveSetsOutstanding--;
  2370.     }
  2371.     pActiveReg->Release();
  2372. }
  2373.     }
  2374.     pval->Release();
  2375. }
  2376.     }
  2377.     break;
  2379. case PT_INTEGER:
  2380.     {
  2381. INT32 i;
  2382. if (!_GetDefaultValInt(
  2383.     plevel->CharStar(),
  2384.     &i, preg))
  2385. {
  2386.     if (!preg->DeleteByName(
  2387. plevel->CharStar()))
  2388.     {
  2389. IHXActiveRegistry* pActiveReg = 0;
  2390. preg->QueryInterface(IID_IHXActiveRegistry,
  2391.     (void**)&pActiveReg);
  2392. if (pActiveReg)
  2393. {
  2394.     m_ActiveSetsOutstanding++;
  2395.     if (HXR_OK != pActiveReg->DeleteActiveProp(
  2396. plevel->CharStar(),
  2397. this))
  2398.     {
  2399. m_ActiveSetsOutstanding--;
  2400.     }
  2401.     pActiveReg->Release();
  2402. }
  2403.     }
  2404. }
  2405. else
  2406. {
  2407.     if (HXR_PROP_ACTIVE == preg->SetIntByName(plevel->CharStar(),
  2408. i))
  2409.     {
  2410. IHXActiveRegistry* pActiveReg = 0;
  2411. preg->QueryInterface(IID_IHXActiveRegistry,
  2412.     (void**)&pActiveReg);
  2413. if (pActiveReg)
  2414. {
  2415.     m_ActiveSetsOutstanding++;
  2416.     if (HXR_OK != pActiveReg->SetActiveInt(
  2417. plevel->CharStar(),
  2418. i, this))
  2419.     {
  2420. m_ActiveSetsOutstanding--;
  2421.     }
  2422.     pActiveReg->Release();
  2423. }
  2424.     }
  2425. }
  2426.     }
  2427.     break;
  2429. case PT_COMPOSITE:
  2430.     ///XXXPM there will be a bug here if we have default vars in sub lists and 
  2431.     //we try and delete the list.  The default vals will not be found here.
  2432.     IHXActiveRegistry* pActiveReg = 0;
  2433.     preg->QueryInterface(IID_IHXActiveRegistry,
  2434. (void**)&pActiveReg);
  2435.     if (pActiveReg)
  2436.     {
  2437. m_ActiveSetsOutstanding++;
  2438. HX_RESULT res;
  2439. res = pActiveReg->DeleteActiveProp(plevel->CharStar(),
  2440.     this);
  2441. if (res != HXR_OK)
  2442. {
  2443.     m_ActiveSetsOutstanding--;
  2444. }
  2445. pActiveReg->Release();
  2446.     }
  2447.     break;
  2449. }
  2451. plevel->RemoveLevel();
  2452. delete pInfo;
  2453.     }
  2455. }
  2457. IHXBuffer*
  2458. XMLConfig::_GetDefaultValString(const char* pProp,
  2459. IHXRegistry2* preg)
  2460. {
  2461.     IHXBuffer* pBuffer = 0;
  2462.     char configdefaults[256]; /* Flawfinder: ignore */
  2463.     HX_ASSERT(strlen(pProp) < 220);
  2464.     SafeSprintf(configdefaults, 256, "configdefaults%s", strchr(pProp, '.'));
  2465.     preg->GetStrByName(configdefaults, pBuffer);
  2466.     return pBuffer;
  2467. }
  2469. int
  2470. XMLConfig::_GetDefaultValInt(const char* pProp, INT32* pOut,
  2471.      IHXRegistry2* preg)
  2472. {
  2473.     char configdefaults[256]; /* Flawfinder: ignore */
  2474.     HX_ASSERT(strlen(pProp) < 220);
  2475.     SafeSprintf(configdefaults, 256, "configdefaults%s", strchr(pProp, '.'));
  2476.     if (HXR_OK != preg->GetIntByName(configdefaults, *pOut))
  2477.     {
  2478. return 0;
  2479.     }
  2480.     return 1;
  2481. }