php/src/IcePHP/Communicator.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <Communicator.h>
  11 #include <Logger.h>
  12 #include <Properties.h>
  13 #include <Proxy.h>
  14 #include <Util.h>
  15 #include <IceUtil/Options.h>
  16 #include <IceUtil/MutexPtrLock.h>
  17 #include <IceUtil/StringUtil.h>
  18 #include <IceUtil/Timer.h>
  19
  20 using namespace std;
  21 using namespace IcePHP;
  22
  23 ZEND_EXTERN_MODULE_GLOBALS(ice)
  24
  25 //
  26 // Class entries represent the PHP class implementations we have registered.
  27 //
  28 namespace IcePHP
  29 {
  30
  31 zend_class_entry* communicatorClassEntry = 0;
  32
  33 //
  34 // An active communicator is in use by at least one request and may have
  35 // registered so that it remains active after a request completes. The
  36 // communicator is destroyed when there are no more references to this
  37 // object.
  38 //
  39 class ActiveCommunicator : public IceUtil::Shared
  40 {
  41 public:
  42
  43     ActiveCommunicator(const Ice::CommunicatorPtr& c);
  44     ~ActiveCommunicator();
  45
  46     const Ice::CommunicatorPtr communicator;
  47     vector<string> ids;
  48     int expires;
  49     IceUtil::Time lastAccess;
  50 };
  51 typedef IceUtil::Handle<ActiveCommunicator> ActiveCommunicatorPtr;
  52
  53 typedef std::map<std::string, zval*> ObjectFactoryMap;
  54
  55 class CommunicatorInfoI : public CommunicatorInfo
  56 {
  57 public:
  58
  59     CommunicatorInfoI(const ActiveCommunicatorPtr&, zval*);
  60
  61     virtual void getZval(zval* TSRMLS_DC);
  62     virtual void addRef(TSRMLS_D);
  63     virtual void decRef(TSRMLS_D);
  64
  65     virtual Ice::CommunicatorPtr getCommunicator() const;
  66
  67     bool addObjectFactory(const std::string&, zval* TSRMLS_DC);
  68     bool findObjectFactory(const std::string&, zval* TSRMLS_DC);
  69     void destroyObjectFactories(TSRMLS_D);
  70
  71     const ActiveCommunicatorPtr ac;
  72     const zval zv;
  73     ObjectFactoryMap objectFactories;
  74 };
  75 typedef IceUtil::Handle<CommunicatorInfoI> CommunicatorInfoIPtr;
  76
  77 //
  78 // Each PHP request has its own set of object factories. More precisely, there is
  79 // an object factory map for each communicator that is created by a PHP request.
  80 // The factory class defined below delegates the create/destroy methods to PHP
  81 // objects supplied by the application. An instance of this class is installed
  82 // as the communicator's default object factory, and the class holds a reference
  83 // to its communicator. When create is invoked, the class resolves the appropriate
  84 // PHP object as follows:
  85 //
  86 //  * Using its communicator reference as the key, look up the corresponding
  87 //    CommunicatorInfoI object in the request-specific communicator map.
  88 //
  89 //  * In the object factory map held by the CommunicatorInfoI object, look for a
  90 //    PHP factory object using the same algorithm as the Ice core.
  91 //
  92 class ObjectFactoryI : public Ice::ObjectFactory
  93 {
  94 public:
  95
  96     ObjectFactoryI(const Ice::CommunicatorPtr&);
  97
  98     virtual Ice::ObjectPtr create(const std::string&);
  99     virtual void destroy();
 100
 101 private:
 102
 103     Ice::CommunicatorPtr _communicator;
 104 };
 105
 106 class ReaperTask : public IceUtil::TimerTask
 107 {
 108 public:
 109
 110     virtual void runTimerTask();
 111 };
 112
 113 }
 114
 115 namespace
 116 {
 117 //
 118 // Communicator support.
 119 //
 120 zend_object_handlers _handlers;
 121
 122 //
 123 // The profile map holds Properties objects corresponding to the "default" profile
 124 // (defined via the ice.config & ice.options settings in php.ini) as well as named
 125 // profiles defined in an external file.
 126 //
 127 typedef map<string, Ice::PropertiesPtr> ProfileMap;
 128 ProfileMap _profiles;
 129 const string _defaultProfileName = "";
 130
 131 //
 132 // This map represents communicators that have been registered so that they can be used
 133 // by multiple PHP requests.
 134 //
 135 typedef map<string, ActiveCommunicatorPtr> RegisteredCommunicatorMap;
 136 RegisteredCommunicatorMap _registeredCommunicators;
 137 IceUtil::Mutex* _registeredCommunicatorsMutex = 0;
 138
 139 IceUtil::TimerPtr _timer;
 140
 141 //
 142 // This map is stored in the "global" variables for each PHP request and holds
 143 // the communicators that have been created (or registered communicators that have
 144 // been used) by the request.
 145 //
 146 typedef map<Ice::CommunicatorPtr, CommunicatorInfoIPtr> CommunicatorMap;
 147
 148 class Init
 149 {
 150 public:
 151
 152     Init()
 153     {
 154         _registeredCommunicatorsMutex = new IceUtil::Mutex();
 155     }
 156
 157     ~Init()
 158     {
 159         delete _registeredCommunicatorsMutex;
 160         _registeredCommunicatorsMutex = 0;
 161     }
 162 };
 163
 164 Init init;
 165 }
 166
 167 extern "C"
 168 {
 169 static zend_object_value handleAlloc(zend_class_entry* TSRMLS_DC);
 170 static void handleFreeStorage(void* TSRMLS_DC);
 171 static zend_object_value handleClone(zval* TSRMLS_DC);
 172 }
 173
 174 ZEND_METHOD(Ice_Communicator, __construct)
 175 {
 176     runtimeError("communicators cannot be instantiated directly" TSRMLS_CC);
 177 }
 178
 179 ZEND_METHOD(Ice_Communicator, destroy)
 180 {
 181     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 182     assert(_this);
 183
 184     //
 185     // Remove all registrations.
 186     //
 187     {
 188         IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_registeredCommunicatorsMutex);
 189         for(vector<string>::iterator p = _this->ac->ids.begin(); p != _this->ac->ids.end(); ++p)
 190         {
 191             _registeredCommunicators.erase(*p);
 192         }
 193         _this->ac->ids.clear();
 194     }
 195
 196     //
 197     // We need to destroy any object factories installed by this request.
 198     //
 199     _this->destroyObjectFactories(TSRMLS_C);
 200
 201     Ice::CommunicatorPtr c = _this->getCommunicator();
 202     assert(c);
 203     CommunicatorMap* m = reinterpret_cast<CommunicatorMap*>(ICE_G(communicatorMap));
 204     assert(m);
 205     assert(m->find(c) != m->end());
 206     m->erase(c);
 207
 208     try
 209     {
 210         c->destroy();
 211     }
 212     catch(const IceUtil::Exception& ex)
 213     {
 214         throwException(ex TSRMLS_CC);
 215         RETURN_NULL();
 216     }
 217 }
 218
 219 ZEND_METHOD(Ice_Communicator, stringToProxy)
 220 {
 221     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 222     assert(_this);
 223
 224     char* str;
 225     int strLen;
 226     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("s"), &str, &strLen) != SUCCESS)
 227     {
 228         RETURN_NULL();
 229     }
 230     string s(str, strLen);
 231
 232     try
 233     {
 234         Ice::ObjectPrx prx = _this->getCommunicator()->stringToProxy(s);
 235         if(!createProxy(return_value, prx, _this TSRMLS_CC))
 236         {
 237             RETURN_NULL();
 238         }
 239     }
 240     catch(const IceUtil::Exception& ex)
 241     {
 242         throwException(ex TSRMLS_CC);
 243         RETURN_NULL();
 244     }
 245 }
 246
 247 ZEND_METHOD(Ice_Communicator, proxyToString)
 248 {
 249     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 250     assert(_this);
 251
 252     zval* zv;
 253     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("O!"), &zv, proxyClassEntry) != SUCCESS)
 254     {
 255         RETURN_NULL();
 256     }
 257
 258     try
 259     {
 260         string str;
 261         if(zv)
 262         {
 263             Ice::ObjectPrx prx;
 264             ClassInfoPtr info;
 265             if(!fetchProxy(zv, prx, info TSRMLS_CC))
 266             {
 267                 RETURN_NULL();
 268             }
 269             assert(prx);
 270             str = prx->ice_toString();
 271         }
 272         RETURN_STRINGL(STRCAST(str.c_str()), str.length(), 1);
 273     }
 274     catch(const IceUtil::Exception& ex)
 275     {
 276         throwException(ex TSRMLS_CC);
 277         RETURN_NULL();
 278     }
 279 }
 280
 281 ZEND_METHOD(Ice_Communicator, propertyToProxy)
 282 {
 283     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 284     assert(_this);
 285
 286     char* str;
 287     int strLen;
 288     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("s"), &str, &strLen) != SUCCESS)
 289     {
 290         RETURN_NULL();
 291     }
 292     string s(str, strLen);
 293
 294     try
 295     {
 296         Ice::ObjectPrx prx = _this->getCommunicator()->propertyToProxy(s);
 297         if(!createProxy(return_value, prx, _this TSRMLS_CC))
 298         {
 299             RETURN_NULL();
 300         }
 301     }
 302     catch(const IceUtil::Exception& ex)
 303     {
 304         throwException(ex TSRMLS_CC);
 305         RETURN_NULL();
 306     }
 307 }
 308
 309 ZEND_METHOD(Ice_Communicator, proxyToProperty)
 310 {
 311     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 312     assert(_this);
 313
 314     zval* zv;
 315     char* str;
 316     int strLen;
 317     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("O!s"), &zv, proxyClassEntry, &str, &strLen)
 318         != SUCCESS)
 319     {
 320         RETURN_NULL();
 321     }
 322
 323     string prefix(str, strLen);
 324
 325     try
 326     {
 327         if(zv)
 328         {
 329             Ice::ObjectPrx prx;
 330             ClassInfoPtr info;
 331             if(!fetchProxy(zv, prx, info TSRMLS_CC))
 332             {
 333                 RETURN_NULL();
 334             }
 335             assert(prx);
 336
 337             Ice::PropertyDict val = _this->getCommunicator()->proxyToProperty(prx, prefix);
 338             if(!createStringMap(return_value, val TSRMLS_CC))
 339             {
 340                 RETURN_NULL();
 341             }
 342         }
 343         else
 344         {
 345             array_init(return_value);
 346         }
 347     }
 348     catch(const IceUtil::Exception& ex)
 349     {
 350         throwException(ex TSRMLS_CC);
 351         RETURN_NULL();
 352     }
 353 }
 354
 355 ZEND_METHOD(Ice_Communicator, stringToIdentity)
 356 {
 357     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 358     assert(_this);
 359
 360     char* str;
 361     int strLen;
 362     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("s"), &str, &strLen) != SUCCESS)
 363     {
 364         RETURN_NULL();
 365     }
 366     string s(str, strLen);
 367
 368     try
 369     {
 370         Ice::Identity id = _this->getCommunicator()->stringToIdentity(s);
 371         if(!createIdentity(return_value, id TSRMLS_CC))
 372         {
 373             RETURN_NULL();
 374         }
 375     }
 376     catch(const IceUtil::Exception& ex)
 377     {
 378         throwException(ex TSRMLS_CC);
 379         RETURN_NULL();
 380     }
 381 }
 382
 383 ZEND_METHOD(Ice_Communicator, identityToString)
 384 {
 385     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 386     assert(_this);
 387
 388     zend_class_entry* identityClass = idToClass("::Ice::Identity" TSRMLS_CC);
 389     assert(identityClass);
 390
 391     zval* zv;
 392     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("O"), &zv, identityClass) != SUCCESS)
 393     {
 394         RETURN_NULL();
 395     }
 396     Ice::Identity id;
 397     if(!extractIdentity(zv, id TSRMLS_CC))
 398     {
 399         RETURN_NULL();
 400     }
 401
 402     try
 403     {
 404         string str = _this->getCommunicator()->identityToString(id);
 405         RETURN_STRINGL(STRCAST(str.c_str()), str.length(), 1);
 406     }
 407     catch(const IceUtil::Exception& ex)
 408     {
 409         throwException(ex TSRMLS_CC);
 410         RETURN_NULL();
 411     }
 412 }
 413
 414 ZEND_METHOD(Ice_Communicator, addObjectFactory)
 415 {
 416     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 417     assert(_this);
 418
 419     zend_class_entry* factoryClass = idToClass("Ice::ObjectFactory" TSRMLS_CC);
 420     assert(factoryClass);
 421
 422     zval* factory;
 423     char* id;
 424     int idLen;
 425     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("Os!"), &factory, factoryClass, &id,
 426                              &idLen TSRMLS_CC) != SUCCESS)
 427     {
 428         RETURN_NULL();
 429     }
 430
 431     string type;
 432     if(id)
 433     {
 434         type = string(id, idLen);
 435     }
 436
 437     if(!_this->addObjectFactory(type, factory TSRMLS_CC))
 438     {
 439         RETURN_NULL();
 440     }
 441 }
 442
 443 ZEND_METHOD(Ice_Communicator, findObjectFactory)
 444 {
 445     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 446     assert(_this);
 447
 448     char* id;
 449     int idLen;
 450     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("s!"), &id, &idLen TSRMLS_CC) != SUCCESS)
 451     {
 452         RETURN_NULL();
 453     }
 454
 455     string type;
 456     if(id)
 457     {
 458         type = string(id, idLen);
 459     }
 460
 461     if(!_this->findObjectFactory(type, return_value TSRMLS_CC))
 462     {
 463         RETURN_NULL();
 464     }
 465 }
 466
 467 ZEND_METHOD(Ice_Communicator, getImplicitContext)
 468 {
 469     runtimeError("not implemented" TSRMLS_CC);
 470 }
 471
 472 ZEND_METHOD(Ice_Communicator, getProperties)
 473 {
 474     if(ZEND_NUM_ARGS() > 0)
 475     {
 476         WRONG_PARAM_COUNT;
 477     }
 478
 479     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 480     assert(_this);
 481
 482     try
 483     {
 484         Ice::PropertiesPtr props = _this->getCommunicator()->getProperties();
 485         if(!createProperties(return_value, props TSRMLS_CC))
 486         {
 487             RETURN_NULL();
 488         }
 489     }
 490     catch(const IceUtil::Exception& ex)
 491     {
 492         throwException(ex TSRMLS_CC);
 493         RETURN_NULL();
 494     }
 495 }
 496
 497 ZEND_METHOD(Ice_Communicator, getLogger)
 498 {
 499     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 500     assert(_this);
 501
 502     try
 503     {
 504         Ice::LoggerPtr logger = _this->getCommunicator()->getLogger();
 505         if(!createLogger(return_value, logger TSRMLS_CC))
 506         {
 507             RETURN_NULL();
 508         }
 509     }
 510     catch(const IceUtil::Exception& ex)
 511     {
 512         throwException(ex TSRMLS_CC);
 513         RETURN_NULL();
 514     }
 515 }
 516
 517 ZEND_METHOD(Ice_Communicator, getDefaultRouter)
 518 {
 519     if(ZEND_NUM_ARGS() > 0)
 520     {
 521         WRONG_PARAM_COUNT;
 522     }
 523
 524     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 525     assert(_this);
 526
 527     try
 528     {
 529         Ice::RouterPrx router = _this->getCommunicator()->getDefaultRouter();
 530         if(router)
 531         {
 532             ClassInfoPtr info = getClassInfoById("::Ice::Router" TSRMLS_CC);
 533             if(!info)
 534             {
 535                 runtimeError("no definition for Ice::Router" TSRMLS_CC);
 536                 RETURN_NULL();
 537             }
 538             if(!createProxy(return_value, router, info, _this TSRMLS_CC))
 539             {
 540                 RETURN_NULL();
 541             }
 542         }
 543         else
 544         {
 545             RETURN_NULL();
 546         }
 547     }
 548     catch(const IceUtil::Exception& ex)
 549     {
 550         throwException(ex TSRMLS_CC);
 551         RETURN_NULL();
 552     }
 553 }
 554
 555 ZEND_METHOD(Ice_Communicator, setDefaultRouter)
 556 {
 557     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 558     assert(_this);
 559
 560     zval* zv;
 561     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("O!"), &zv, proxyClassEntry TSRMLS_CC) !=
 562         SUCCESS)
 563     {
 564         RETURN_NULL();
 565     }
 566
 567     Ice::ObjectPrx proxy;
 568     ClassInfoPtr info;
 569     if(zv && !fetchProxy(zv, proxy, info TSRMLS_CC))
 570     {
 571         RETURN_NULL();
 572     }
 573
 574     try
 575     {
 576         Ice::RouterPrx router;
 577         if(proxy)
 578         {
 579             if(!info || !info->isA("::Ice::Router"))
 580             {
 581                 invalidArgument("setDefaultRouter requires a proxy narrowed to Ice::Router" TSRMLS_CC);
 582                 RETURN_NULL();
 583             }
 584             router = Ice::RouterPrx::uncheckedCast(proxy);
 585         }
 586         _this->getCommunicator()->setDefaultRouter(router);
 587     }
 588     catch(const IceUtil::Exception& ex)
 589     {
 590         throwException(ex TSRMLS_CC);
 591         RETURN_NULL();
 592     }
 593 }
 594
 595 ZEND_METHOD(Ice_Communicator, getDefaultLocator)
 596 {
 597     if(ZEND_NUM_ARGS() > 0)
 598     {
 599         WRONG_PARAM_COUNT;
 600     }
 601
 602     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 603     assert(_this);
 604
 605     try
 606     {
 607         Ice::LocatorPrx locator = _this->getCommunicator()->getDefaultLocator();
 608         if(locator)
 609         {
 610             ClassInfoPtr info = getClassInfoById("::Ice::Locator" TSRMLS_CC);
 611             if(!info)
 612             {
 613                 runtimeError("no definition for Ice::Locator" TSRMLS_CC);
 614                 RETURN_NULL();
 615             }
 616             if(!createProxy(return_value, locator, info, _this TSRMLS_CC))
 617             {
 618                 RETURN_NULL();
 619             }
 620         }
 621         else
 622         {
 623             RETURN_NULL();
 624         }
 625     }
 626     catch(const IceUtil::Exception& ex)
 627     {
 628         throwException(ex TSRMLS_CC);
 629         RETURN_NULL();
 630     }
 631 }
 632
 633 ZEND_METHOD(Ice_Communicator, setDefaultLocator)
 634 {
 635     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 636     assert(_this);
 637
 638     zval* zv;
 639     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("O!"), &zv, proxyClassEntry TSRMLS_CC) !=
 640         SUCCESS)
 641     {
 642         RETURN_NULL();
 643     }
 644
 645     Ice::ObjectPrx proxy;
 646     ClassInfoPtr info;
 647     if(zv && !fetchProxy(zv, proxy, info TSRMLS_CC))
 648     {
 649         RETURN_NULL();
 650     }
 651
 652     try
 653     {
 654         Ice::LocatorPrx locator;
 655         if(proxy)
 656         {
 657             if(!info || !info->isA("::Ice::Locator"))
 658             {
 659                 invalidArgument("setDefaultLocator requires a proxy narrowed to Ice::Locator" TSRMLS_CC);
 660                 RETURN_NULL();
 661             }
 662             locator = Ice::LocatorPrx::uncheckedCast(proxy);
 663         }
 664         _this->getCommunicator()->setDefaultLocator(locator);
 665     }
 666     catch(const IceUtil::Exception& ex)
 667     {
 668         throwException(ex TSRMLS_CC);
 669         RETURN_NULL();
 670     }
 671 }
 672
 673 ZEND_METHOD(Ice_Communicator, flushBatchRequests)
 674 {
 675     CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
 676     assert(_this);
 677
 678     if(ZEND_NUM_ARGS() != 8)
 679     {
 680         WRONG_PARAM_COUNT;
 681     }
 682
 683     try
 684     {
 685         _this->getCommunicator()->flushBatchRequests();
 686     }
 687     catch(const IceUtil::Exception& ex)
 688     {
 689         throwException(ex TSRMLS_CC);
 690         RETURN_NULL();
 691     }
 692 }
 693
 694 #ifdef _WIN32
 695 extern "C"
 696 #endif
 697 static zend_object_value
 698 handleAlloc(zend_class_entry* ce TSRMLS_DC)
 699 {
 700     zend_object_value result;
 701
 702     Wrapper<CommunicatorInfoIPtr>* obj = Wrapper<CommunicatorInfoIPtr>::create(ce TSRMLS_CC);
 703     assert(obj);
 704
 705     result.handle = zend_objects_store_put(obj, 0, (zend_objects_free_object_storage_t)handleFreeStorage, 0 TSRMLS_CC);
 706     result.handlers = &_handlers;
 707
 708     return result;
 709 }
 710
 711 #ifdef _WIN32
 712 extern "C"
 713 #endif
 714 static void
 715 handleFreeStorage(void* p TSRMLS_DC)
 716 {
 717     Wrapper<CommunicatorInfoIPtr>* obj = static_cast<Wrapper<CommunicatorInfoIPtr>*>(p);
 718     delete obj->ptr;
 719     zend_objects_free_object_storage(static_cast<zend_object*>(p) TSRMLS_CC);
 720 }
 721
 722 #ifdef _WIN32
 723 extern "C"
 724 #endif
 725 static zend_object_value
 726 handleClone(zval* zv TSRMLS_DC)
 727 {
 728     php_error_docref(0 TSRMLS_CC, E_ERROR, "communicators cannot be cloned");
 729     return zend_object_value();
 730 }
 731
 732 static CommunicatorInfoIPtr
 733 createCommunicator(zval* zv, const ActiveCommunicatorPtr& ac TSRMLS_DC)
 734 {
 735     try
 736     {
 737         if(object_init_ex(zv, communicatorClassEntry) != SUCCESS)
 738         {
 739             runtimeError("unable to initialize communicator object" TSRMLS_CC);
 740             return 0;
 741         }
 742
 743         Wrapper<CommunicatorInfoIPtr>* obj = Wrapper<CommunicatorInfoIPtr>::extract(zv TSRMLS_CC);
 744         assert(!obj->ptr);
 745
 746         CommunicatorInfoIPtr info = new CommunicatorInfoI(ac, zv);
 747         obj->ptr = new CommunicatorInfoIPtr(info);
 748
 749         CommunicatorMap* m;
 750         if(ICE_G(communicatorMap))
 751         {
 752             m = reinterpret_cast<CommunicatorMap*>(ICE_G(communicatorMap));
 753         }
 754         else
 755         {
 756             m = new CommunicatorMap;
 757             ICE_G(communicatorMap) = m;
 758         }
 759         m->insert(CommunicatorMap::value_type(ac->communicator, info));
 760
 761         return info;
 762     }
 763     catch(const IceUtil::Exception& ex)
 764     {
 765         throwException(ex TSRMLS_CC);
 766         return 0;
 767     }
 768 }
 769
 770 static CommunicatorInfoIPtr
 771 initializeCommunicator(zval* zv, Ice::StringSeq& args, bool hasArgs, const Ice::InitializationData& initData TSRMLS_DC)
 772 {
 773     try
 774     {
 775         Ice::CommunicatorPtr c;
 776         if(hasArgs)
 777         {
 778             c = Ice::initialize(args, initData);
 779         }
 780         else
 781         {
 782             c = Ice::initialize(initData);
 783         }
 784
 785         ActiveCommunicatorPtr ac = new ActiveCommunicator(c);
 786
 787         //
 788         // Install a default object factory that delegates to PHP factories.
 789         //
 790         c->addObjectFactory(new ObjectFactoryI(c), "");
 791
 792         CommunicatorInfoIPtr info = createCommunicator(zv, ac TSRMLS_CC);
 793         if(!info)
 794         {
 795             try
 796             {
 797                 c->destroy();
 798             }
 799             catch(...)
 800             {
 801             }
 802         }
 803
 804         return info;
 805     }
 806     catch(const IceUtil::Exception& ex)
 807     {
 808         throwException(ex TSRMLS_CC);
 809         return 0;
 810     }
 811 }
 812
 813 ZEND_FUNCTION(Ice_initialize)
 814 {
 815     if(ZEND_NUM_ARGS() > 2)
 816     {
 817         runtimeError("too many arguments" TSRMLS_CC);
 818         RETURN_NULL();
 819     }
 820
 821     zend_class_entry* initClass = idToClass("::Ice::InitializationData" TSRMLS_CC);
 822     assert(initClass);
 823
 824     //
 825     // Retrieve the arguments.
 826     //
 827     zval*** args = static_cast<zval***>(emalloc(ZEND_NUM_ARGS() * sizeof(zval**)));
 828     AutoEfree autoArgs(args); // Call efree on return
 829     if(zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE)
 830     {
 831         runtimeError("unable to get arguments" TSRMLS_CC);
 832         RETURN_NULL();
 833     }
 834
 835     Ice::StringSeq seq;
 836     Ice::InitializationData initData;
 837     zval* zvinit = 0;
 838
 839     //
 840     // Accept the following invocations:
 841     //
 842     // initialize(array, InitializationData)
 843     // initialize(array)
 844     // initialize(InitializationData)
 845     // initialize()
 846     //
 847     bool hasArgs = false;
 848     if(ZEND_NUM_ARGS())
 849     {
 850         if(Z_TYPE_PP(args[0]) == IS_ARRAY)
 851         {
 852             if(!extractStringArray(*args[0], seq TSRMLS_CC))
 853             {
 854                 RETURN_NULL();
 855             }
 856             hasArgs = true;
 857             if(ZEND_NUM_ARGS() > 1)
 858             {
 859                 if(Z_TYPE_PP(args[1]) != IS_OBJECT || Z_OBJCE_PP(args[1]) != initClass)
 860                 {
 861                     string s = zendTypeToString(Z_TYPE_PP(args[1]));
 862                     invalidArgument("expected InitializationData object but received %s" TSRMLS_CC, s.c_str());
 863                     RETURN_NULL();
 864                 }
 865                 zvinit = *args[1];
 866             }
 867         }
 868         else if(Z_TYPE_PP(args[0]) == IS_OBJECT && Z_OBJCE_PP(args[0]) == initClass)
 869         {
 870             if(ZEND_NUM_ARGS() > 1)
 871             {
 872                 runtimeError("too many arguments" TSRMLS_CC);
 873                 RETURN_NULL();
 874             }
 875             zvinit = *args[0];
 876         }
 877         else
 878         {
 879             string s = zendTypeToString(Z_TYPE_PP(args[0]));
 880             invalidArgument("unexpected argument type %s" TSRMLS_CC, s.c_str());
 881             RETURN_NULL();
 882         }
 883     }
 884
 885     if(zvinit)
 886     {
 887         void* data;
 888         string member;
 889
 890         member = "properties";
 891         if(zend_hash_find(Z_OBJPROP_P(zvinit), STRCAST(member.c_str()), member.size() + 1, &data) == SUCCESS)
 892         {
 893             zval** val = reinterpret_cast<zval**>(data);
 894             if(!fetchProperties(*val, initData.properties TSRMLS_CC))
 895             {
 896                 RETURN_NULL();
 897             }
 898         }
 899
 900         member = "logger";
 901         if(zend_hash_find(Z_OBJPROP_P(zvinit), STRCAST(member.c_str()), member.size() + 1, &data) == SUCCESS)
 902         {
 903             zval** val = reinterpret_cast<zval**>(data);
 904             if(!fetchLogger(*val, initData.logger TSRMLS_CC))
 905             {
 906                 RETURN_NULL();
 907             }
 908         }
 909     }
 910
 911     CommunicatorInfoIPtr info = initializeCommunicator(return_value, seq, hasArgs, initData TSRMLS_CC);
 912     if(!info)
 913     {
 914         RETURN_NULL();
 915     }
 916 }
 917
 918 ZEND_FUNCTION(Ice_register)
 919 {
 920     zval* comm;
 921     char* s;
 922     int sLen;
 923     long expires = 0;
 924     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("Os|l"), &comm, communicatorClassEntry, &s,
 925                              &sLen, &expires TSRMLS_CC) != SUCCESS)
 926     {
 927         RETURN_NULL();
 928     }
 929
 930     string id(s, sLen);
 931     if(id.empty())
 932     {
 933         invalidArgument("communicator id cannot be empty" TSRMLS_CC);
 934         RETURN_NULL();
 935     }
 936
 937     CommunicatorInfoIPtr info = Wrapper<CommunicatorInfoIPtr>::value(comm TSRMLS_CC);
 938     assert(info);
 939
 940     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_registeredCommunicatorsMutex);
 941
 942     RegisteredCommunicatorMap::iterator p = _registeredCommunicators.find(id);
 943     if(p != _registeredCommunicators.end())
 944     {
 945         if(p->second->communicator != info->getCommunicator())
 946         {
 947             //
 948             // A different communicator is already registered with that ID.
 949             //
 950             RETURN_FALSE;
 951         }
 952     }
 953     else
 954     {
 955         info->ac->ids.push_back(id);
 956         _registeredCommunicators[id] = info->ac;
 957     }
 958
 959     if(expires > 0)
 960     {
 961         //
 962         // Update the expiration time. If a communicator is registered with multiple IDs, we
 963         // always use the most recent expiration setting.
 964         //
 965         info->ac->expires = static_cast<int>(expires);
 966         info->ac->lastAccess = IceUtil::Time::now();
 967
 968         //
 969         // Start the timer if necessary. Reap expired communicators every five minutes.
 970         //
 971         if(!_timer)
 972         {
 973             _timer = new IceUtil::Timer;
 974             _timer->scheduleRepeated(new ReaperTask, IceUtil::Time::seconds(5 * 60));
 975         }
 976     }
 977
 978     RETURN_TRUE;
 979 }
 980
 981 ZEND_FUNCTION(Ice_unregister)
 982 {
 983     char* s;
 984     int sLen;
 985     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("s"), &s, &sLen TSRMLS_CC) != SUCCESS)
 986     {
 987         RETURN_NULL();
 988     }
 989
 990     string id(s, sLen);
 991
 992     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_registeredCommunicatorsMutex);
 993
 994     RegisteredCommunicatorMap::iterator p = _registeredCommunicators.find(id);
 995     if(p == _registeredCommunicators.end())
 996     {
 997         //
 998         // No communicator registered with that ID.
 999         //
1000         RETURN_FALSE;
1001     }
1002
1003     //
1004     // Remove the ID from the ActiveCommunicator's list of registered IDs.
1005     //
1006     ActiveCommunicatorPtr ac = p->second;
1007     vector<string>::iterator q = find(ac->ids.begin(), ac->ids.end(), id);
1008     assert(q != ac->ids.end());
1009     ac->ids.erase(q);
1010
1011     _registeredCommunicators.erase(p);
1012
1013     RETURN_TRUE;
1014 }
1015
1016 ZEND_FUNCTION(Ice_find)
1017 {
1018     char* s;
1019     int sLen;
1020     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("s"), &s, &sLen TSRMLS_CC) != SUCCESS)
1021     {
1022         RETURN_NULL();
1023     }
1024
1025     string id(s, sLen);
1026
1027     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_registeredCommunicatorsMutex);
1028
1029     RegisteredCommunicatorMap::iterator p = _registeredCommunicators.find(id);
1030     if(p == _registeredCommunicators.end())
1031     {
1032         //
1033         // No communicator registered with that ID.
1034         //
1035         RETURN_NULL();
1036     }
1037
1038     if(p->second->expires > 0)
1039     {
1040         p->second->lastAccess = IceUtil::Time::now();
1041     }
1042
1043     //
1044     // Check if this communicator has already been obtained by the current request.
1045     // If so, we can return the existing PHP object that corresponds to the communicator.
1046     //
1047     CommunicatorMap* m = reinterpret_cast<CommunicatorMap*>(ICE_G(communicatorMap));
1048     if(m)
1049     {
1050         CommunicatorMap::iterator q = m->find(p->second->communicator);
1051         if(q != m->end())
1052         {
1053             q->second->getZval(return_value TSRMLS_CC);
1054             return;
1055         }
1056     }
1057
1058     if(!createCommunicator(return_value, p->second TSRMLS_CC))
1059     {
1060         RETURN_NULL();
1061     }
1062 }
1063
1064 ZEND_FUNCTION(Ice_getProperties)
1065 {
1066     char* s = 0;
1067     int sLen;
1068     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("|s"), &s, &sLen TSRMLS_CC) != SUCCESS)
1069     {
1070         RETURN_NULL();
1071     }
1072
1073     string name;
1074     if(s)
1075     {
1076         name = string(s, sLen);
1077     }
1078
1079     ProfileMap::iterator p = _profiles.find(name);
1080     if(p == _profiles.end())
1081     {
1082         RETURN_NULL();
1083     }
1084
1085     Ice::PropertiesPtr clone = p->second->clone();
1086     if(!createProperties(return_value, clone TSRMLS_CC))
1087     {
1088         RETURN_NULL();
1089     }
1090 }
1091
1092 //
1093 // Predefined methods for Communicator.
1094 //
1095 static function_entry _interfaceMethods[] =
1096 {
1097     {0, 0, 0}
1098 };
1099 static function_entry _classMethods[] =
1100 {
1101     ZEND_ME(Ice_Communicator, __construct, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
1102     ZEND_ME(Ice_Communicator, destroy, NULL, ZEND_ACC_PUBLIC)
1103     ZEND_ME(Ice_Communicator, stringToProxy, NULL, ZEND_ACC_PUBLIC)
1104     ZEND_ME(Ice_Communicator, proxyToString, NULL, ZEND_ACC_PUBLIC)
1105     ZEND_ME(Ice_Communicator, propertyToProxy, NULL, ZEND_ACC_PUBLIC)
1106     ZEND_ME(Ice_Communicator, proxyToProperty, NULL, ZEND_ACC_PUBLIC)
1107     ZEND_ME(Ice_Communicator, stringToIdentity, NULL, ZEND_ACC_PUBLIC)
1108     ZEND_ME(Ice_Communicator, identityToString, NULL, ZEND_ACC_PUBLIC)
1109     ZEND_ME(Ice_Communicator, addObjectFactory, NULL, ZEND_ACC_PUBLIC)
1110     ZEND_ME(Ice_Communicator, findObjectFactory, NULL, ZEND_ACC_PUBLIC)
1111     ZEND_ME(Ice_Communicator, getImplicitContext, NULL, ZEND_ACC_PUBLIC)
1112     ZEND_ME(Ice_Communicator, getProperties, NULL, ZEND_ACC_PUBLIC)
1113     ZEND_ME(Ice_Communicator, getLogger, NULL, ZEND_ACC_PUBLIC)
1114     ZEND_ME(Ice_Communicator, getDefaultRouter, NULL, ZEND_ACC_PUBLIC)
1115     ZEND_ME(Ice_Communicator, setDefaultRouter, NULL, ZEND_ACC_PUBLIC)
1116     ZEND_ME(Ice_Communicator, getDefaultLocator, NULL, ZEND_ACC_PUBLIC)
1117     ZEND_ME(Ice_Communicator, setDefaultLocator, NULL, ZEND_ACC_PUBLIC)
1118     ZEND_ME(Ice_Communicator, flushBatchRequests, NULL, ZEND_ACC_PUBLIC)
1119     {0, 0, 0}
1120 };
1121
1122 static bool
1123 createProfile(const string& name, const string& config, const string& options TSRMLS_DC)
1124 {
1125     ProfileMap::iterator p = _profiles.find(name);
1126     if(p != _profiles.end())
1127     {
1128         php_error_docref(0 TSRMLS_CC, E_WARNING, "duplicate Ice profile `%s'", name.c_str());
1129         return false;
1130     }
1131
1132     Ice::PropertiesPtr properties = Ice::createProperties();
1133
1134     if(!config.empty())
1135     {
1136         try
1137         {
1138             properties->load(config);
1139         }
1140         catch(const IceUtil::Exception& ex)
1141         {
1142             ostringstream ostr;
1143             ex.ice_print(ostr);
1144             php_error_docref(0 TSRMLS_CC, E_WARNING, "unable to load Ice configuration file %s:\n%s", config.c_str(),
1145                              ostr.str().c_str());
1146             return false;
1147         }
1148     }
1149
1150     if(!options.empty())
1151     {
1152         vector<string> args;
1153         try
1154         {
1155             args = IceUtilInternal::Options::split(options);
1156         }
1157         catch(const IceUtil::Exception& ex)
1158         {
1159             ostringstream ostr;
1160             ex.ice_print(ostr);
1161             string msg = ostr.str();
1162             php_error_docref(0 TSRMLS_CC, E_WARNING, "error occurred while parsing the options `%s':\n%s",
1163                              options.c_str(), msg.c_str());
1164             return false;
1165         }
1166
1167         properties->parseCommandLineOptions("", args);
1168     }
1169
1170     _profiles[name] = properties;
1171     return true;
1172 }
1173
1174 static bool
1175 parseProfiles(const string& file TSRMLS_DC)
1176 {
1177     //
1178     // The Zend engine doesn't export a function for loading an INI file, so we
1179     // have to do it ourselves. The format is:
1180     //
1181     // [profile-name]
1182     // ice.config = config-file
1183     // ice.options = args
1184     //
1185     ifstream in(file.c_str());
1186     if(!in)
1187     {
1188         php_error_docref(0 TSRMLS_CC, E_WARNING, "unable to open Ice profiles in %s", file.c_str());
1189         return false;
1190     }
1191
1192     string name, config, options;
1193     char line[1024];
1194     while(in.getline(line, 1024))
1195     {
1196         const string delim = " \t\r\n";
1197         string s = line;
1198
1199         string::size_type idx = s.find(';');
1200         if(idx != string::npos)
1201         {
1202             s.erase(idx);
1203         }
1204
1205         idx = s.find_last_not_of(delim);
1206         if(idx != string::npos && idx + 1 < s.length())
1207         {
1208             s.erase(idx + 1);
1209         }
1210
1211         string::size_type beg = s.find_first_not_of(delim);
1212         if(beg == string::npos)
1213         {
1214             continue;
1215         }
1216
1217         if(s[beg] == '[')
1218         {
1219             beg++;
1220             string::size_type end = s.find_first_of(" \t]", beg);
1221             if(end == string::npos || s[s.length() - 1] != ']')
1222             {
1223                 php_error_docref(0 TSRMLS_CC, E_WARNING, "invalid profile section in file %s:\n%s\n", file.c_str(),
1224                                  line);
1225                 return false;
1226             }
1227
1228             if(!name.empty())
1229             {
1230                 createProfile(name, config, options TSRMLS_CC);
1231                 config.clear();
1232                 options.clear();
1233             }
1234
1235             name = s.substr(beg, end - beg);
1236         }
1237         else
1238         {
1239             string::size_type end = s.find_first_of(delim + "=", beg);
1240             assert(end != string::npos);
1241
1242             string key = s.substr(beg, end - beg);
1243
1244             end = s.find('=', end);
1245             if(end == string::npos)
1246             {
1247                 php_error_docref(0 TSRMLS_CC, E_WARNING, "invalid profile entry in file %s:\n%s\n", file.c_str(), line);
1248                 return false;
1249             }
1250             ++end;
1251
1252             string value;
1253             beg = s.find_first_not_of(delim, end);
1254             if(beg != string::npos)
1255             {
1256                 end = s.length();
1257                 value = s.substr(beg, end - beg);
1258
1259                 //
1260                 // Check for quotes and remove them if present
1261                 //
1262                 string::size_type qpos = IceUtilInternal::checkQuote(value);
1263                 if(qpos != string::npos)
1264                 {
1265                     value = value.substr(1, qpos - 1);
1266                 }
1267             }
1268
1269             if(key == "config" || key == "ice.config")
1270             {
1271                 config = value;
1272             }
1273             else if(key == "options" || key == "ice.options")
1274             {
1275                 options = value;
1276             }
1277             else
1278             {
1279                 php_error_docref(0 TSRMLS_CC, E_WARNING, "unknown profile entry in file %s:\n%s\n", file.c_str(), line);
1280             }
1281
1282             if(name.empty())
1283             {
1284                 php_error_docref(0 TSRMLS_CC, E_WARNING, "no section for profile entry in file %s:\n%s\n", file.c_str(),
1285                                  line);
1286                 return false;
1287             }
1288         }
1289     }
1290
1291     if(!name.empty())
1292     {
1293         if(!createProfile(name, config, options TSRMLS_CC))
1294         {
1295             return false;
1296         }
1297     }
1298
1299     return true;
1300 }
1301
1302 bool
1303 IcePHP::communicatorInit(TSRMLS_D)
1304 {
1305     //
1306     // We register an interface and a class that implements the interface. This allows
1307     // applications to safely include the Slice-generated code for the type.
1308     //
1309
1310     //
1311     // Register the Communicator interface.
1312     //
1313     zend_class_entry ce;
1314 #ifdef ICEPHP_USE_NAMESPACES
1315     INIT_NS_CLASS_ENTRY(ce, STRCAST("Ice"), STRCAST("Communicator"), _interfaceMethods);
1316 #else
1317     INIT_CLASS_ENTRY(ce, "Ice_Communicator", _interfaceMethods);
1318 #endif
1319     zend_class_entry* interface = zend_register_internal_interface(&ce TSRMLS_CC);
1320
1321     //
1322     // Register the Communicator class.
1323     //
1324     INIT_CLASS_ENTRY(ce, "IcePHP_Communicator", _classMethods);
1325     ce.create_object = handleAlloc;
1326     communicatorClassEntry = zend_register_internal_class(&ce TSRMLS_CC);
1327     memcpy(&_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1328     _handlers.clone_obj = handleClone;
1329     zend_class_implements(communicatorClassEntry TSRMLS_CC, 1, interface);
1330
1331     //
1332     // Create the profiles from configuration settings.
1333     //
1334     const char* empty = "";
1335     const char* config = INI_STR("ice.config");
1336     if(!config)
1337     {
1338         config = empty;
1339     }
1340     const char* options = INI_STR("ice.options");
1341     if(!options)
1342     {
1343         options = empty;
1344     }
1345     if(!createProfile(_defaultProfileName, config, options TSRMLS_CC))
1346     {
1347         return false;
1348     }
1349
1350     const char* profiles = INI_STR("ice.profiles");
1351     if(!profiles)
1352     {
1353         profiles = empty;
1354     }
1355     if(strlen(profiles) > 0)
1356     {
1357         if(!parseProfiles(profiles TSRMLS_CC))
1358         {
1359             return false;
1360         }
1361
1362         if(INI_BOOL(const_cast<char*>("ice.hide_profiles")))
1363         {
1364             memset(const_cast<char*>(profiles), '*', strlen(profiles));
1365             //
1366             // For some reason the code below does not work as expected. It causes a call
1367             // to ini_get_all() to segfault.
1368             //
1369             /*
1370             if(zend_alter_ini_entry("ice.profiles", sizeof("ice.profiles"), "<hidden>", sizeof("<hidden>") - 1,
1371                                     PHP_INI_ALL, PHP_INI_STAGE_STARTUP) == FAILURE)
1372             {
1373                 return false;
1374             }
1375             */
1376         }
1377     }
1378
1379     return true;
1380 }
1381
1382 bool
1383 IcePHP::communicatorShutdown(TSRMLS_D)
1384 {
1385     _profiles.clear();
1386
1387     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_registeredCommunicatorsMutex);
1388
1389     if(_timer)
1390     {
1391         _timer->destroy();
1392         _timer = 0;
1393     }
1394
1395     //
1396     // Clearing the map releases the last remaining reference counts of the ActiveCommunicator
1397     // objects. The ActiveCommunicator destructor destroys its communicator.
1398     //
1399     _registeredCommunicators.clear();
1400
1401     return true;
1402 }
1403
1404 bool
1405 IcePHP::communicatorRequestInit(TSRMLS_D)
1406 {
1407     ICE_G(communicatorMap) = 0;
1408
1409     return true;
1410 }
1411
1412 bool
1413 IcePHP::communicatorRequestShutdown(TSRMLS_D)
1414 {
1415     if(ICE_G(communicatorMap))
1416     {
1417         CommunicatorMap* m = static_cast<CommunicatorMap*>(ICE_G(communicatorMap));
1418         for(CommunicatorMap::iterator p = m->begin(); p != m->end(); ++p)
1419         {
1420             CommunicatorInfoIPtr info = p->second;
1421
1422             //
1423             // We need to destroy any object factories installed during this request.
1424             //
1425             info->destroyObjectFactories(TSRMLS_C);
1426         }
1427
1428         //
1429         // Deleting the map decrements the reference count of its ActiveCommunicator
1430         // values. If there are no other references to an ActiveCommunicator, its
1431         // destructor destroys the communicator.
1432         //
1433         delete m;
1434     }
1435
1436     return true;
1437 }
1438
1439 IcePHP::ActiveCommunicator::ActiveCommunicator(const Ice::CommunicatorPtr& c) :
1440     communicator(c), expires(0)
1441 {
1442 }
1443
1444 IcePHP::ActiveCommunicator::~ActiveCommunicator()
1445 {
1446     //
1447     // There are no more references to this communicator, so we can safely destroy it now.
1448     //
1449     try
1450     {
1451         communicator->destroy();
1452     }
1453     catch(...)
1454     {
1455     }
1456 }
1457
1458 IcePHP::CommunicatorInfoI::CommunicatorInfoI(const ActiveCommunicatorPtr& c, zval* z) :
1459     ac(c),
1460     zv(*z) // This is legal - it simply copies the object's handle.
1461 {
1462 }
1463
1464 void
1465 IcePHP::CommunicatorInfoI::getZval(zval* z TSRMLS_DC)
1466 {
1467     Z_TYPE_P(z) = IS_OBJECT;
1468     z->value.obj = zv.value.obj;
1469     addRef(TSRMLS_C);
1470 }
1471
1472 void
1473 IcePHP::CommunicatorInfoI::addRef(TSRMLS_D)
1474 {
1475     zval* p = const_cast<zval*>(&zv);
1476     Z_OBJ_HT_P(p)->add_ref(p TSRMLS_CC);
1477 }
1478
1479 void
1480 IcePHP::CommunicatorInfoI::decRef(TSRMLS_D)
1481 {
1482     zval* p = const_cast<zval*>(&zv);
1483     Z_OBJ_HT(zv)->del_ref(p TSRMLS_CC);
1484 }
1485
1486 Ice::CommunicatorPtr
1487 IcePHP::CommunicatorInfoI::getCommunicator() const
1488 {
1489     return ac->communicator;
1490 }
1491
1492 bool
1493 IcePHP::CommunicatorInfoI::addObjectFactory(const string& id, zval* factory TSRMLS_DC)
1494 {
1495     ObjectFactoryMap::iterator p = objectFactories.find(id);
1496     if(p != objectFactories.end())
1497     {
1498         Ice::AlreadyRegisteredException ex(__FILE__, __LINE__);
1499         ex.kindOfObject = "object factory";
1500         ex.id = id;
1501         throwException(ex TSRMLS_CC);
1502         return false;
1503     }
1504
1505     objectFactories.insert(ObjectFactoryMap::value_type(id, factory));
1506     Z_ADDREF_P(factory);
1507
1508     return true;
1509 }
1510
1511 bool
1512 IcePHP::CommunicatorInfoI::findObjectFactory(const string& id, zval* zv TSRMLS_DC)
1513 {
1514     ObjectFactoryMap::iterator p = objectFactories.find(id);
1515     if(p != objectFactories.end())
1516     {
1517         *zv = *p->second; // This is legal - it simply copies the object's handle.
1518         INIT_PZVAL(zv);
1519         zval_copy_ctor(zv);
1520         return true;
1521     }
1522
1523     return false;
1524 }
1525
1526 void
1527 IcePHP::CommunicatorInfoI::destroyObjectFactories(TSRMLS_D)
1528 {
1529     for(ObjectFactoryMap::iterator p = objectFactories.begin(); p != objectFactories.end(); ++p)
1530     {
1531         //
1532         // Invoke the destroy method on each registered PHP factory.
1533         //
1534         invokeMethod(p->second, "destroy" TSRMLS_CC);
1535         zend_clear_exception(TSRMLS_C);
1536         zval_ptr_dtor(&p->second);
1537     }
1538 }
1539
1540 IcePHP::ObjectFactoryI::ObjectFactoryI(const Ice::CommunicatorPtr& communicator) :
1541     _communicator(communicator)
1542 {
1543 }
1544
1545 Ice::ObjectPtr
1546 IcePHP::ObjectFactoryI::create(const string& id)
1547 {
1548     //
1549     // Get the TSRM id for the current request.
1550     //
1551     TSRMLS_FETCH();
1552
1553     CommunicatorMap* m = static_cast<CommunicatorMap*>(ICE_G(communicatorMap));
1554     assert(m);
1555     CommunicatorMap::iterator p = m->find(_communicator);
1556     assert(p != m->end());
1557
1558     CommunicatorInfoIPtr info = p->second;
1559
1560     zval* factory = 0;
1561
1562     //
1563     // Check if the application has registered a factory for this id.
1564     //
1565     ObjectFactoryMap::iterator q = info->objectFactories.find(id);
1566     if(q == info->objectFactories.end())
1567     {
1568         q = info->objectFactories.find(""); // Look for a default factory.
1569     }
1570     if(q != info->objectFactories.end())
1571     {
1572         factory = q->second;
1573     }
1574
1575     //
1576     // Get the type information.
1577     //
1578     ClassInfoPtr cls = getClassInfoById(id TSRMLS_CC);
1579     if(!cls)
1580     {
1581         return 0;
1582     }
1583
1584     if(factory)
1585     {
1586         zval* arg;
1587         MAKE_STD_ZVAL(arg);
1588         ZVAL_STRINGL(arg, STRCAST(id.c_str()), id.length(), 1);
1589
1590         zval* obj = 0;
1591
1592         zend_try
1593         {
1594             const char* func = "create";
1595             zend_call_method(&factory, 0, 0, const_cast<char*>(func), strlen(func), &obj, 1, arg, 0 TSRMLS_CC);
1596         }
1597         zend_catch
1598         {
1599             obj = 0;
1600         }
1601         zend_end_try();
1602
1603         zval_ptr_dtor(&arg);
1604
1605         //
1606         // Bail out if an exception has already been thrown.
1607         //
1608         if(!obj || EG(exception))
1609         {
1610             throw AbortMarshaling();
1611         }
1612
1613         AutoDestroy destroy(obj);
1614
1615         if(Z_TYPE_P(obj) == IS_NULL)
1616         {
1617             return 0;
1618         }
1619
1620         return new ObjectReader(obj, cls, info TSRMLS_CC);
1621     }
1622
1623     //
1624     // If the requested type is an abstract class, then we give up.
1625     //
1626     if(cls->isAbstract)
1627     {
1628         return 0;
1629     }
1630
1631     //
1632     // Instantiate the object.
1633     //
1634     zval* obj;
1635     MAKE_STD_ZVAL(obj);
1636     AutoDestroy destroy(obj);
1637
1638     if(object_init_ex(obj, cls->zce) != SUCCESS)
1639     {
1640         throw AbortMarshaling();
1641     }
1642
1643     if(!invokeMethod(obj, ZEND_CONSTRUCTOR_FUNC_NAME TSRMLS_CC))
1644     {
1645         throw AbortMarshaling();
1646     }
1647
1648     return new ObjectReader(obj, cls, info TSRMLS_CC);
1649 }
1650
1651 void
1652 IcePHP::ObjectFactoryI::destroy()
1653 {
1654     _communicator = 0;
1655 }
1656
1657 void
1658 IcePHP::ReaperTask::runTimerTask()
1659 {
1660     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_registeredCommunicatorsMutex);
1661
1662     IceUtil::Time now = IceUtil::Time::now();
1663     RegisteredCommunicatorMap::iterator p = _registeredCommunicators.begin();
1664     while(p != _registeredCommunicators.end())
1665     {
1666         if(p->second->lastAccess + IceUtil::Time::seconds(p->second->expires * 60) <= now)
1667         {
1668             try
1669             {
1670                 p->second->communicator->destroy();
1671             }
1672             catch(...)
1673             {
1674             }
1675             _registeredCommunicators.erase(p++);
1676         }
1677         else
1678         {
1679             ++p;
1680         }
1681     }
1682 }