ACE/ACEXML/apps/svcconf/Svcconf_Handler.cpp

   1 #include "Svcconf_Handler.h"
   2 #include "ace/ACE.h"
   3 #include "ace/Log_Msg.h"
   4 #include "ace/Service_Config.h"
   5 #include "ace/Service_Types.h"
   6 #include "ace/Service_Repository.h"
   7 #include "ace/Service_Gestalt.h"
   8 #include "ace/DLL.h"
   9 #include "ace/ARGV.h"
  10 #include "ace/Module.h"
  11 #include "ace/OS_NS_strings.h"
  12 #include "ace/SString.h"
  13
  14 #if (ACE_USES_CLASSIC_SVC_CONF == 0)
  15
  16 #if !defined (__ACEXML_INLINE__)
  17 # include "Svcconf_Handler.inl"
  18 #endif /* __ACEXML_INLINE__ */
  19
  20 ACEXML_Svcconf_Handler::ACEXML_Svcconf_Handler ()
  21   : in_stream_def_ (0),
  22     in_module_ (0),
  23     stream_svc_type_ (0),
  24     stream_ (0)
  25 {
  26 }
  27
  28 ACEXML_Svcconf_Handler::~ACEXML_Svcconf_Handler ()
  29 {
  30 }
  31
  32 void
  33 ACEXML_Svcconf_Handler::characters (const ACEXML_Char *,
  34                                     int,
  35                                     int)
  36 {
  37 }
  38
  39 void
  40 ACEXML_Svcconf_Handler::endDocument ()
  41 {
  42 }
  43
  44 void
  45 ACEXML_Svcconf_Handler::endElement (const ACEXML_Char *,
  46                                     const ACEXML_Char *,
  47                                     const ACEXML_Char *qName)
  48 {
  49   if (ACE_OS::strcmp (qName, ACE_TEXT ("dynamic")) == 0)
  50     {
  51       ACE_Parsed_Info *active_info = (this->in_stream_def_ == 0 ?
  52                                       &this->parsed_info_ :
  53                                       &this->stream_info_);
  54
  55       // We must allocate a string here to ensure that the
  56       // name is still available by the time the
  57       // ACE_Service_Type_Dynamic_Guard is destructed.
  58       ACE_TString name = active_info->name ();
  59       ACE_Service_Type_Dynamic_Guard dummy (
  60         *ACE_Service_Config::current ()->current_service_repository (),
  61         name.c_str ());
  62       ACE_DLL svc_dll;
  63
  64       if (svc_dll.open (active_info->path ()) == -1)
  65         {
  66           // build the error message
  67           ACE_TString msg (ACE_TEXT ("Cannot locate DLL: '"));
  68           msg += ACE_TString (active_info->path ());
  69           msg += ACE_TString (ACE_TEXT ("' for entity '"));
  70           msg += ACE_TString (active_info->name ());
  71           msg += ACE_TString (ACE_TEXT ("'\n"));
  72
  73           throw ACEXML_SAXException (msg.c_str ());
  74         }
  75
  76       void *(*func) (ACE_Service_Object_Exterminator *) = 0;
  77       ACE_Service_Object_Exterminator gobbler = 0;
  78       void *symbol = 0;
  79
  80       long temp_ptr =
  81         reinterpret_cast<long> (svc_dll.symbol (active_info->init_func ()));
  82       func = reinterpret_cast<void *(*)(ACE_Service_Object_Exterminator *)> (temp_ptr);
  83
  84       if (func == 0)
  85         {
  86           // build the error message
  87           ACE_TString msg (ACE_TEXT ("Cannot locate init function: '"));
  88           msg += ACE_TString (active_info->init_func ());
  89           msg += ACE_TString (ACE_TEXT ("' for entity '"));
  90           msg += ACE_TString (active_info->name ());
  91           msg += ACE_TString (ACE_TEXT ("'\n"));
  92
  93           throw ACEXML_SAXException (msg.c_str ());
  94         }
  95       symbol = (*func)(&gobbler); // target object created in the loaded DLL.
  96
  97       ACE_Service_Type_Impl *stp = ACE_Service_Config::create_service_type_impl
  98         (active_info->name (),
  99          active_info->service_type (),
 100          symbol,
 101          ACE_Service_Type::DELETE_THIS |
 102          ACE_Service_Type::DELETE_OBJ,
 103          gobbler);
 104
 105       if (this->in_stream_def_)
 106         {
 107 //           ACE_DEBUG ((LM_INFO, ACE_TEXT ("Create dynamic %s for stream\n"),
 108 //                       this->stream_info_.name ()));
 109           if (active_info->service_type () == ACE_Service_Type::STREAM)
 110             {
 111               this->stream_ = (ACE_Stream_Type *) stp;
 112             }
 113           else
 114             {
 115               // We will not retain this stream
 116               delete stp;
 117
 118               // build the error message
 119               ACE_TString msg (ACE_TEXT ("Expecting Stream type in stream header"));
 120               msg += ACE_TString (ACE_TEXT (" for entity '"));
 121               msg += ACE_TString (active_info->name ());
 122               msg += ACE_TString (ACE_TEXT ("'\n"));
 123
 124               throw ACEXML_SAXException (msg.c_str ());
 125             }
 126
 127           this->stream_svc_type_ =
 128             ACE_Service_Config::create_service_type (this->stream_info_.name (),
 129                                                      this->stream_,
 130                                                      svc_dll,
 131                                                      this->stream_info_.active ());
 132         }
 133       else
 134         {
 135           if (this->in_module_)
 136             {
 137               ACE_ARGV args (active_info->init_params ());
 138
 139               ACE_Module_Type *mt = (ACE_Module_Type *) stp;
 140
 141               ACE_Module<ACE_SYNCH> *mp = (ACE_Module<ACE_SYNCH> *) mt->object ();
 142
 143               if (ACE_OS::strcmp (mp->name (), active_info->name ()) != 0)
 144                 {
 145                   ACE_DEBUG ((LM_DEBUG,
 146                               ACE_TEXT ("warning: assigning Module_Type name %s to Module %s since names differ\n"),
 147                               active_info->name (),
 148                               mp->name ()));
 149                   mp->name (active_info->name ());
 150                 }
 151
 152               if (mt->init (args.argc (), args.argv ()) == -1
 153                   || this->stream_->push (mt) == -1)
 154                 {
 155                   // build the error message
 156                   ACE_TString msg (ACE_TEXT ("Error initializing module"));
 157                   msg += ACE_TString (ACE_TEXT (" for entity '"));
 158                   msg += ACE_TString (active_info->name ());
 159                   msg += ACE_TString (ACE_TEXT ("'\n"));
 160
 161                   throw ACEXML_SAXException (msg.c_str ());
 162                 }
 163
 164
 165 //               ACE_DEBUG ((LM_INFO, ACE_TEXT ("Push dynamic %s into stream %s\n"),
 166 //                           this->parsed_info_.name (),
 167 //                           this->stream_info_.name ()));
 168             }
 169           else
 170             {
 171               ACE_Service_Type *stype =
 172                 ACE_Service_Config::create_service_type (active_info->name (),
 173                                                          stp,
 174                                                          svc_dll,
 175                                                          active_info->active ());
 176               // @@ Check error here.
 177
 178               //               ACE_DEBUG ((LM_INFO, ACE_TEXT ("Apply dynamic %s\n"),
 179 //                           this->parsed_info_.name ()));
 180               if (ACE_Service_Config::initialize (stype,
 181                                                   active_info->init_params ()) == -1)
 182                 {
 183                   // If it did not initialize correctly, the
 184                   // ACE_Service_Config doesn't own this object
 185                   delete stype;
 186
 187                   // build the error message
 188                   ACE_TString msg (ACE_TEXT ("Failed to initialize dynamic service"));
 189                   msg += ACE_TString (ACE_TEXT (" for entity '"));
 190                   msg += ACE_TString (active_info->name ());
 191                   msg += ACE_TString (ACE_TEXT ("'\n"));
 192
 193                   throw ACEXML_SAXException (msg.c_str ());
 194                 }
 195             }
 196           this->parsed_info_.reset ();
 197         }
 198     }
 199   else if (ACE_OS::strcmp (qName, ACE_TEXT ("static")) == 0)
 200     {
 201       if (this->in_stream_def_)
 202         {
 203           // @@ Couldn't make sense out of the original Svc_Conf.y.
 204           ACE_DEBUG ((LM_ERROR, ACE_TEXT ("Create static %s for stream\n"),
 205                       this->stream_info_.name ()));
 206         }
 207       else
 208         {
 209           if (this->in_module_)
 210             {
 211               // @@ Couldn't make sense out of the original Svc_Conf.y.
 212               ACE_DEBUG ((LM_ERROR, ACE_TEXT ("Push static %s into stream %s\n"),
 213                           this->parsed_info_.name (),
 214                           this->stream_info_.name ()));
 215             }
 216           else
 217             {
 218 //               ACE_DEBUG ((LM_INFO, ACE_TEXT ("Apply static %s\n"),
 219 //                           this->parsed_info_.name ()));
 220               if (ACE_Service_Config::initialize (this->parsed_info_.name (),
 221                                                   this->parsed_info_.init_params ()) == -1)
 222                 {
 223                   // build the error message
 224                   ACE_TString msg (ACE_TEXT ("Failed to initialize static service"));
 225                   msg += ACE_TString (ACE_TEXT (" for entity '"));
 226                   msg += ACE_TString (this->parsed_info_.name ());
 227                   msg += ACE_TString (ACE_TEXT ("'\n"));
 228
 229                   throw ACEXML_SAXException (msg.c_str ());
 230                 }
 231             }
 232           this->parsed_info_.reset ();
 233         }
 234     }
 235   else if (ACE_OS::strcmp (qName, ACE_TEXT ("module")) == 0)
 236     {
 237       this->in_module_ = 0;
 238     }
 239   else if (ACE_OS::strcmp (qName, ACE_TEXT ("streamdef")) == 0)
 240     {
 241 //       ACE_DEBUG ((LM_INFO, ACE_TEXT ("Apply stream %s of type %s\n"),
 242 //                   this->stream_info_.name (),
 243 //                   this->stream_info_.name ()));
 244       ACE_Service_Config::initialize (this->stream_svc_type_,
 245                                       this->stream_info_.init_params ());
 246
 247       this->stream_info_.reset ();
 248       this->stream_svc_type_ = 0;
 249       this->stream_ = 0;
 250     }
 251   else if (ACE_OS::strcmp (qName, ACE_TEXT ("stream")) == 0)
 252     {
 253 //       ACE_DEBUG ((LM_INFO, ACE_TEXT ("Apply stream %s of type %s\n"),
 254 //                   this->stream_info_.name (),
 255 //                   this->stream_info_.name ()));
 256       this->stream_info_.reset ();
 257     }
 258   else
 259     {
 260     }
 261 }
 262
 263 void
 264 ACEXML_Svcconf_Handler::endPrefixMapping (const ACEXML_Char *)
 265 {
 266 }
 267
 268 void
 269 ACEXML_Svcconf_Handler::ignorableWhitespace (const ACEXML_Char *,
 270                                              int,
 271                                              int)
 272 {
 273 }
 274
 275 void
 276 ACEXML_Svcconf_Handler::processingInstruction (const ACEXML_Char *,
 277                                                const ACEXML_Char *)
 278 {
 279 }
 280
 281 void
 282 ACEXML_Svcconf_Handler::setDocumentLocator (ACEXML_Locator* locator)
 283 {
 284   this->locator_ = locator;
 285 }
 286
 287 void
 288 ACEXML_Svcconf_Handler::skippedEntity (const ACEXML_Char *)
 289 {
 290 }
 291
 292 void
 293 ACEXML_Svcconf_Handler::startDocument ()
 294 {
 295 }
 296
 297 void
 298 ACEXML_Svcconf_Handler::startElement (const ACEXML_Char *,
 299                                       const ACEXML_Char *,
 300                                       const ACEXML_Char *qName,
 301                                       ACEXML_Attributes *alist)
 302 {
 303   if (ACE_OS::strcmp (qName, ACE_TEXT ("dynamic")) == 0)
 304     {
 305       this->get_dynamic_attrs (alist);
 306     }
 307   else if (ACE_OS::strcmp (qName, ACE_TEXT ("initializer")) == 0)
 308     {
 309       this->get_initializer_attrs (alist);
 310     }
 311   else if (ACE_OS::strcmp (qName, ACE_TEXT ("static")) == 0)
 312     {
 313       this->get_static_attrs (alist);
 314     }
 315   else if (ACE_OS::strcmp (qName, ACE_TEXT ("stream")) == 0)
 316     {
 317       this->get_stream_id (alist);
 318
 319       if (ACE_Service_Repository::instance()->find
 320           (this->stream_info_.name (),
 321            (const ACE_Service_Type **) &this->stream_svc_type_) == -1)
 322         {
 323           // build the error message
 324           ACE_TString msg (ACE_TEXT ("Cannot find stream '"));
 325           msg += ACE_TString (this->stream_info_.name ());
 326           msg += ACE_TString (ACE_TEXT ("'\n"));
 327
 328           throw ACEXML_SAXException (msg.c_str ());
 329         }
 330       this->stream_ =   this->stream_svc_type_ == 0
 331         ? 0
 332         : dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (this->stream_svc_type_->type ()));
 333
 334 //       ACE_DEBUG ((LM_INFO, ACE_TEXT ("Retrieve stream %s from repository\n"),
 335 //                   this->stream_info_.name ()));
 336     }
 337   else if (ACE_OS::strcmp (qName, ACE_TEXT ("streamdef")) == 0)
 338     {
 339       this->in_stream_def_ = 1;
 340       // @@ Set up stream service object
 341     }
 342   else if (ACE_OS::strcmp (qName, ACE_TEXT ("module")) == 0)
 343     {
 344       this->in_stream_def_ = 0;
 345       this->in_module_ = 1;
 346     }
 347   else if (ACE_OS::strcmp (qName, ACE_TEXT ("resume")) == 0)
 348     {
 349       this->get_id (alist);
 350       if (this->in_module_)
 351         {
 352 //           ACE_DEBUG ((LM_INFO, ACE_TEXT ("Resume %s in stream %s\n"),
 353 //                       this->parsed_info_.name (),
 354 //                       this->stream_info_.name ()));
 355           ACE_Module_Type *mt = (this->stream_ == 0)
 356             ? 0
 357             : this->stream_->find (this->parsed_info_.name ());
 358
 359           if (mt == 0)
 360             {
 361               // build the error message
 362               ACE_TString msg (ACE_TEXT ("Can't locate module '"));
 363               msg += ACE_TString (this->parsed_info_.name ());
 364               msg += ACE_TString (ACE_TEXT ("'\n"));
 365
 366               throw ACEXML_SAXException (msg.c_str ());
 367             }
 368
 369           mt->resume ();
 370         }
 371       else
 372         {
 373 //           ACE_DEBUG ((LM_INFO, ACE_TEXT ("Resume %s\n"),
 374 //                       this->parsed_info_.name ()));
 375           if (ACE_Service_Config::resume (this->parsed_info_.name ()) == -1)
 376             {
 377               // build the error message
 378               ACE_TString msg (ACE_TEXT ("Resume failed"));
 379               msg += ACE_TString (ACE_TEXT (" for entity '"));
 380               msg += ACE_TString (this->parsed_info_.name ());
 381               msg += ACE_TString (ACE_TEXT ("'\n"));
 382
 383               throw ACEXML_SAXException (msg.c_str ());
 384             }
 385         }
 386       this->parsed_info_.reset ();
 387     }
 388   else if (ACE_OS::strcmp (qName, ACE_TEXT ("suspend")) == 0)
 389     {
 390       this->get_id (alist);
 391       if (this->in_module_)
 392         {
 393 //           ACE_DEBUG ((LM_INFO, ACE_TEXT ("Suspend %s in stream %s\n"),
 394 //                       this->parsed_info_.name (),
 395 //                       this->stream_info_.name ()));
 396           ACE_Module_Type *mt = (this->stream_ == 0)
 397             ? 0
 398             : this->stream_->find (this->parsed_info_.name ());
 399
 400           if (mt == 0)
 401             {
 402               // build the error message
 403               ACE_TString msg (ACE_TEXT ("Can't locate module '"));
 404               msg += ACE_TString (this->parsed_info_.name ());
 405               msg += ACE_TString (ACE_TEXT ("'\n"));
 406
 407               throw ACEXML_SAXException (msg.c_str ());
 408             }
 409
 410           mt->suspend ();
 411         }
 412       else
 413         {
 414           //          ACE_DEBUG ((LM_INFO, ACE_TEXT ("Suspend %s\n"),
 415           //                      this->parsed_info_.name ()));
 416           if (ACE_Service_Config::suspend (this->parsed_info_.name ()) == -1)
 417             {
 418               // build the error message
 419               ACE_TString msg (ACE_TEXT ("Suspend failed"));
 420               msg += ACE_TString (ACE_TEXT (" for entity '"));
 421               msg += ACE_TString (this->parsed_info_.name ());
 422               msg += ACE_TString (ACE_TEXT ("'\n"));
 423
 424               throw ACEXML_SAXException (msg.c_str ());
 425             }
 426         }
 427       this->parsed_info_.reset ();
 428     }
 429   else if (ACE_OS::strcmp (qName, ACE_TEXT ("remove")) == 0)
 430     {
 431       this->get_id (alist);
 432       if (this->in_module_)
 433         {
 434 //           ACE_DEBUG ((LM_INFO, ACE_TEXT ("Remove %s in stream %s\n"),
 435 //                       this->parsed_info_.name (),
 436 //                       this->stream_info_.name ()));
 437           ACE_Module_Type *mt = (this->stream_ == 0)
 438             ? 0
 439             : this->stream_->find (this->parsed_info_.name ());
 440
 441           if (mt == 0)
 442             {
 443               // build the error message
 444               ACE_TString msg (ACE_TEXT ("Can't locate module '"));
 445               msg += ACE_TString (this->parsed_info_.name ());
 446               msg += ACE_TString (ACE_TEXT ("'\n"));
 447
 448               throw ACEXML_SAXException (msg.c_str ());
 449             }
 450
 451           this->stream_->remove (mt);
 452         }
 453       else
 454         {
 455 //           ACE_DEBUG ((LM_INFO, ACE_TEXT ("Remove %s\n"),
 456 //                       this->parsed_info_.name ()));
 457           if (ACE_Service_Config::remove (this->parsed_info_.name ()) == -1)
 458             {
 459               // build the error message
 460               ACE_TString msg (ACE_TEXT ("Remove failed"));
 461               msg += ACE_TString (ACE_TEXT (" for entity '"));
 462               msg += ACE_TString (this->parsed_info_.name ());
 463               msg += ACE_TString (ACE_TEXT ("'\n"));
 464
 465               throw ACEXML_SAXException (msg.c_str ());
 466             }
 467         }
 468       this->parsed_info_.reset ();
 469     }
 470   else if (ACE_OS::strcmp (qName, ACE_TEXT ("ACE_Svc_Conf")) == 0)
 471     {
 472       // Main document tag. no-op.
 473 //       ACE_DEBUG ((LM_INFO, ACE_TEXT ("ACE_Svc_Conf tag\n")));
 474     }
 475   else
 476     {
 477       // @@ Error.  Perhaps we should relay to user event handler here, if available.
 478     }
 479
 480   return;
 481 }
 482
 483 void
 484 ACEXML_Svcconf_Handler::startPrefixMapping (const ACEXML_Char *,
 485                                             const ACEXML_Char *)
 486 {
 487   // No-op.
 488 }
 489
 490 // *** Methods inherit from ACEXML_DTDHandler.
 491
 492 void
 493 ACEXML_Svcconf_Handler::notationDecl (const ACEXML_Char *,
 494                                       const ACEXML_Char *,
 495                                       const ACEXML_Char *)
 496 {
 497   // No-op.
 498 }
 499
 500 void
 501 ACEXML_Svcconf_Handler::unparsedEntityDecl (const ACEXML_Char *,
 502                                             const ACEXML_Char *,
 503                                             const ACEXML_Char *,
 504                                             const ACEXML_Char *)
 505 {
 506   // No-op.
 507 }
 508
 509 // Methods inherit from ACEXML_EnitityResolver.
 510
 511 ACEXML_InputSource *
 512 ACEXML_Svcconf_Handler::resolveEntity (const ACEXML_Char *,
 513                                        const ACEXML_Char *)
 514 {
 515   // No-op.
 516   return 0;
 517 }
 518
 519 // Methods inherit from ACEXML_ErrorHandler.
 520
 521   /*
 522    * Receive notification of a recoverable error.
 523    */
 524 void
 525 ACEXML_Svcconf_Handler::error (ACEXML_SAXParseException& ex)
 526 {
 527   ACE_DEBUG ((LM_DEBUG, "%s: line :%d col: %d ", this->locator_->getSystemId(),
 528               this->locator_->getLineNumber(),
 529               this->locator_->getColumnNumber()));
 530   ex.print();
 531 }
 532
 533 void
 534 ACEXML_Svcconf_Handler::fatalError (ACEXML_SAXParseException& ex)
 535 {
 536   ACE_DEBUG ((LM_DEBUG, "%s: line :%d col: %d ", this->locator_->getSystemId(),
 537               this->locator_->getLineNumber(),
 538               this->locator_->getColumnNumber()));
 539   ex.print();
 540 }
 541
 542 void
 543 ACEXML_Svcconf_Handler::warning (ACEXML_SAXParseException& ex)
 544 {
 545   ACE_DEBUG ((LM_DEBUG, "%s: line :%d col: %d ", this->locator_->getSystemId(),
 546               this->locator_->getLineNumber(),
 547               this->locator_->getColumnNumber()));
 548   ex.print();
 549 }
 550
 551 int
 552 ACEXML_Svcconf_Handler::get_stream_id (ACEXML_Attributes *alist)
 553 {
 554   if (alist != 0)
 555     for (size_t i = 0; i < alist->getLength (); ++i)
 556       {
 557         if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("id")) == 0)
 558           {
 559             this->stream_info_.name (alist->getValue (i));
 560           }
 561         else
 562           {
 563             // build the error message
 564             ACE_TString msg (ACE_TEXT ("Invalid stream attribute '"));
 565             msg += ACE_TString (alist->getQName (i));
 566             msg += ACE_TString (ACE_TEXT ("' for entity '"));
 567             msg += ACE_TString (this->stream_info_.name ());
 568             msg += ACE_TString (ACE_TEXT ("'\n"));
 569
 570             throw ACEXML_SAXException (msg.c_str ());
 571           }
 572       }
 573   return 0;
 574 }
 575
 576 int
 577 ACEXML_Svcconf_Handler::get_id (ACEXML_Attributes *alist)
 578 {
 579   if (alist != 0)
 580     for (size_t i = 0; i < alist->getLength (); ++i)
 581       {
 582         if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("id")) == 0)
 583           {
 584             this->parsed_info_.name (alist->getValue (i));
 585           }
 586         else
 587           {
 588             // build the error message
 589             ACE_TString msg (ACE_TEXT ("Invalid attribute '"));
 590             msg += ACE_TString (alist->getQName (i));
 591             msg += ACE_TString (ACE_TEXT ("', expecting 'id'"));
 592             msg += ACE_TString (ACE_TEXT (" for entity '"));
 593             msg += ACE_TString (this->parsed_info_.name ());
 594             msg += ACE_TString (ACE_TEXT ("'\n"));
 595
 596             throw ACEXML_SAXException (msg.c_str ());
 597           }
 598       }
 599   return 0;
 600 }
 601
 602 int
 603 ACEXML_Svcconf_Handler::get_dynamic_attrs (ACEXML_Attributes *alist)
 604 {
 605   if (alist != 0)
 606     {
 607       ACE_Parsed_Info *info = (this->in_stream_def_ == 0 ?
 608                                &this->parsed_info_ :
 609                                &this->stream_info_);
 610       for (size_t i = 0; i < alist->getLength (); ++i)
 611         {
 612           if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("id")) == 0)
 613             {
 614               info->name (alist->getValue (i));
 615             }
 616           else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("status")) == 0)
 617             {
 618               if (ACE_OS::strcmp (alist->getValue (i), ACE_TEXT ("inactive")) == 0)
 619                 {
 620                   info->active (0);
 621                 }
 622               else if (ACE_OS::strcmp (alist->getValue (i), ACE_TEXT ("active")) == 0)
 623                 {
 624                   info->active (1);
 625                 }
 626               else
 627                 {
 628                   // build the error message
 629                   ACE_TString msg (ACE_TEXT ("Invalid attribute value '"));
 630                   msg += ACE_TString (alist->getQName (i));
 631                   msg += ACE_TString (ACE_TEXT ("', expecting 'active' or 'inactive'"));
 632                   msg += ACE_TString (ACE_TEXT (" for entity '"));
 633                   msg += ACE_TString (info->name ());
 634                   msg += ACE_TString (ACE_TEXT ("'\n"));
 635
 636                   throw ACEXML_SAXException (msg.c_str ());
 637                 }
 638             }
 639           else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("type")) == 0)
 640             {
 641               if (ACE_OS::strcasecmp (alist->getValue (i), ACE_TEXT ("service_object")) == 0)
 642                 {
 643                   info->service_type (ACE_Service_Type::SERVICE_OBJECT);
 644                 }
 645               else if (ACE_OS::strcasecmp (alist->getValue (i), ACE_TEXT ("stream")) == 0)
 646                 {
 647                   info->service_type (ACE_Service_Type::STREAM);
 648                 }
 649               else if (ACE_OS::strcasecmp (alist->getValue (i), ACE_TEXT ("module")) == 0)
 650                 {
 651                   info->service_type (ACE_Service_Type::MODULE);
 652                 }
 653               else
 654                 {
 655                   // build the error message
 656                   ACE_TString msg (ACE_TEXT ("Invalid Service_Object attribute value'"));
 657                   msg += ACE_TString (alist->getQName (i));
 658                   msg += ACE_TString (ACE_TEXT ("' for entity '"));
 659                   msg += ACE_TString (info->name ());
 660                   msg += ACE_TString (ACE_TEXT ("'\n"));
 661
 662                   throw ACEXML_SAXException (msg.c_str ());
 663                 }
 664             }
 665           else
 666             {
 667               // build the error message
 668               ACE_TString msg (ACE_TEXT ("Invalid attribute'"));
 669               msg += ACE_TString (alist->getQName (i));
 670               msg += ACE_TString (ACE_TEXT ("' for entity '"));
 671               msg += ACE_TString (info->name ());
 672               msg += ACE_TString (ACE_TEXT ("'\n"));
 673
 674               throw ACEXML_SAXException (msg.c_str ());
 675             }
 676         }
 677     }
 678   return 0;
 679 }
 680
 681 int
 682 ACEXML_Svcconf_Handler::get_initializer_attrs (ACEXML_Attributes *alist)
 683 {
 684   if (alist != 0)
 685     {
 686       ACE_Parsed_Info *info = (this->in_stream_def_ == 0 ?
 687                                &this->parsed_info_ :
 688                                &this->stream_info_);
 689       for (size_t i = 0; i < alist->getLength (); ++i)
 690         {
 691           if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("init")) == 0)
 692             {
 693               info->init_func (alist->getValue (i));
 694             }
 695           else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("path")) == 0)
 696             {
 697               info->path (alist->getValue (i));
 698             }
 699           else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("params")) == 0)
 700             {
 701               info->init_params (alist->getValue (i));
 702             }
 703           else
 704             {
 705               // build the error message
 706               ACE_TString msg (ACE_TEXT ("Invalid initializer attribute'"));
 707               msg += ACE_TString (alist->getQName (i));
 708               msg += ACE_TString (ACE_TEXT ("' for entity '"));
 709               msg += ACE_TString (info->name ());
 710               msg += ACE_TString (ACE_TEXT ("'\n"));
 711
 712               throw ACEXML_SAXException (msg.c_str ());
 713             }
 714         }
 715     }
 716   return 0;
 717 }
 718
 719 int
 720 ACEXML_Svcconf_Handler::get_static_attrs (ACEXML_Attributes *alist)
 721 {
 722   if (alist != 0)
 723     {
 724       ACE_Parsed_Info *info = (this->in_stream_def_ == 0 ?
 725                                &this->parsed_info_ :
 726                                &this->stream_info_);
 727       for (size_t i = 0; i < alist->getLength (); ++i)
 728         {
 729           if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("id")) == 0)
 730             {
 731               info->name (alist->getValue (i));
 732             }
 733           else if (ACE_OS::strcmp (alist->getQName (i), ACE_TEXT ("params")) == 0)
 734             {
 735               info->init_params (alist->getValue (i));
 736             }
 737           else
 738             {
 739               // build the error message
 740               ACE_TString msg (ACE_TEXT ("Invalid static attribute '"));
 741               msg += ACE_TString (alist->getQName (i));
 742               msg += ACE_TString (ACE_TEXT ("' for entity '"));
 743               msg += ACE_TString (info->name ());
 744               msg += ACE_TString (ACE_TEXT ("'\n"));
 745
 746               throw ACEXML_SAXException (msg.c_str ());
 747             }
 748         }
 749     }
 750   return 0;
 751 }
 752
 753 #endif /* ACE_USES_CLASSIC_SVC_CONF == 0 */