cpp/src/IceSSL/EndpointI.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 <IceSSL/EndpointI.h>
  11 #include <IceSSL/AcceptorI.h>
  12 #include <IceSSL/ConnectorI.h>
  13 #include <IceSSL/TransceiverI.h>
  14 #include <IceSSL/Instance.h>
  15 #include <Ice/Network.h>
  16 #include <Ice/BasicStream.h>
  17 #include <Ice/LocalException.h>
  18 #include <Ice/DefaultsAndOverrides.h>
  19 #include <Ice/HashUtil.h>
  20
  21 using namespace std;
  22 using namespace Ice;
  23 using namespace IceSSL;
  24
  25 IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& ho, Int po, Int ti, const string& conId,
  26                              bool co) :
  27     _instance(instance),
  28     _host(ho),
  29     _port(po),
  30     _timeout(ti),
  31     _connectionId(conId),
  32     _compress(co)
  33 {
  34 }
  35
  36 IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& str, bool oaEndpoint) :
  37     _instance(instance),
  38     _port(0),
  39     _timeout(-1),
  40     _compress(false)
  41 {
  42     const string delim = " \t\n\r";
  43
  44     string::size_type beg;
  45     string::size_type end = 0;
  46
  47     while(true)
  48     {
  49         beg = str.find_first_not_of(delim, end);
  50         if(beg == string::npos)
  51         {
  52             break;
  53         }
  54
  55         end = str.find_first_of(delim, beg);
  56         if(end == string::npos)
  57         {
  58             end = str.length();
  59         }
  60
  61         string option = str.substr(beg, end - beg);
  62         if(option.length() != 2 || option[0] != '-')
  63         {
  64             EndpointParseException ex(__FILE__, __LINE__);
  65             ex.str = "expected an endpoint option but found `" + option + "' in endpoint `ssl " + str + "'";
  66             throw ex;
  67         }
  68
  69         string argument;
  70         string::size_type argumentBeg = str.find_first_not_of(delim, end);
  71         if(argumentBeg != string::npos && str[argumentBeg] != '-')
  72         {
  73             beg = argumentBeg;
  74             end = str.find_first_of(delim, beg);
  75             if(end == string::npos)
  76             {
  77                 end = str.length();
  78             }
  79             argument = str.substr(beg, end - beg);
  80             if(argument[0] == '\"' && argument[argument.size() - 1] == '\"')
  81             {
  82                 argument = argument.substr(1, argument.size() - 2);
  83             }
  84         }
  85
  86         switch(option[1])
  87         {
  88             case 'h':
  89             {
  90                 if(argument.empty())
  91                 {
  92                     EndpointParseException ex(__FILE__, __LINE__);
  93                     ex.str = "no argument provided for -h option in endpoint `ssl " + str + "'";
  94                     throw ex;
  95                 }
  96                 const_cast<string&>(_host) = argument;
  97                 break;
  98             }
  99
 100             case 'p':
 101             {
 102                 if(argument.empty())
 103                 {
 104                     EndpointParseException ex(__FILE__, __LINE__);
 105                     ex.str = "no argument provided for -p option in endpoint `ssl " + str + "'";
 106                     throw ex;
 107                 }
 108                 istringstream p(argument);
 109                 if(!(p >> const_cast<Int&>(_port)) || !p.eof())
 110                 {
 111                     EndpointParseException ex(__FILE__, __LINE__);
 112                     ex.str = "invalid port value `" + argument + "' in endpoint `ssl " + str + "'";
 113                     throw ex;
 114                 }
 115                 else if(_port < 0 || _port > 65535)
 116                 {
 117                     EndpointParseException ex(__FILE__, __LINE__);
 118                     ex.str = "port value `" + argument + "' out of range in endpoint `ssl " + str + "'";
 119                     throw ex;
 120                 }
 121                 break;
 122             }
 123
 124             case 't':
 125             {
 126                 if(argument.empty())
 127                 {
 128                     EndpointParseException ex(__FILE__, __LINE__);
 129                     ex.str = "no argument provided for -t option in endpoint `ssl " + str + "'";
 130                     throw ex;
 131                 }
 132                 istringstream t(argument);
 133                 if(!(t >> const_cast<Int&>(_timeout)) || !t.eof())
 134                 {
 135                     EndpointParseException ex(__FILE__, __LINE__);
 136                     ex.str = "invalid timeout value `" + argument + "' in endpoint `ssl " + str + "'";
 137                     throw ex;
 138                 }
 139                 break;
 140             }
 141
 142             case 'z':
 143             {
 144                 if(!argument.empty())
 145                 {
 146                     EndpointParseException ex(__FILE__, __LINE__);
 147                     ex.str = "unexpected argument `" + argument + "' provided for -z option in `ssl " + str + "'";
 148                     throw ex;
 149                 }
 150                 const_cast<bool&>(_compress) = true;
 151                 break;
 152             }
 153
 154             default:
 155             {
 156                 EndpointParseException ex(__FILE__, __LINE__);
 157                 ex.str = "unknown option `" + option + "' in `ssl " + str + "'";
 158                 throw ex;
 159             }
 160         }
 161     }
 162
 163     if(_host.empty())
 164     {
 165         const_cast<string&>(_host) = _instance->defaultHost();
 166     }
 167     else if(_host == "*")
 168     {
 169         if(oaEndpoint)
 170         {
 171             const_cast<string&>(_host) = string();
 172         }
 173         else
 174         {
 175             EndpointParseException ex(__FILE__, __LINE__);
 176             ex.str = "`-h *' not valid for proxy endpoint `ssl " + str + "'";
 177             throw ex;
 178         }
 179     }
 180 }
 181
 182 IceSSL::EndpointI::EndpointI(const InstancePtr& instance, IceInternal::BasicStream* s) :
 183     _instance(instance),
 184     _port(0),
 185     _timeout(-1),
 186     _compress(false)
 187 {
 188     s->startReadEncaps();
 189     s->read(const_cast<string&>(_host), false);
 190     s->read(const_cast<Int&>(_port));
 191     s->read(const_cast<Int&>(_timeout));
 192     s->read(const_cast<bool&>(_compress));
 193     s->endReadEncaps();
 194 }
 195
 196 void
 197 IceSSL::EndpointI::streamWrite(IceInternal::BasicStream* s) const
 198 {
 199     s->write(EndpointType);
 200     s->startWriteEncaps();
 201     s->write(_host, false);
 202     s->write(_port);
 203     s->write(_timeout);
 204     s->write(_compress);
 205     s->endWriteEncaps();
 206 }
 207
 208 string
 209 IceSSL::EndpointI::toString() const
 210 {
 211     //
 212     // WARNING: Certain features, such as proxy validation in Glacier2,
 213     // depend on the format of proxy strings. Changes to toString() and
 214     // methods called to generate parts of the reference string could break
 215     // these features. Please review for all features that depend on the
 216     // format of proxyToString() before changing this and related code.
 217     //
 218     ostringstream s;
 219     s << "ssl";
 220
 221     if(!_host.empty())
 222     {
 223         s << " -h ";
 224         bool addQuote = _host.find(':') != string::npos;
 225         if(addQuote)
 226         {
 227             s << "\"";
 228         }
 229         s << _host;
 230         if(addQuote)
 231         {
 232             s << "\"";
 233         }
 234     }
 235
 236     s << " -p " << _port;
 237     if(_timeout != -1)
 238     {
 239         s << " -t " << _timeout;
 240     }
 241     if(_compress)
 242     {
 243         s << " -z";
 244     }
 245     return s.str();
 246 }
 247
 248 //
 249 // COMPILERFIX: VC6 complains about an ambiguous "EndpointInfo" symbol when this class is defined inside
 250 //              getInfo(). Moving the definition into an anonymous namespace works around it.
 251 //
 252 namespace
 253 {
 254     class InfoI : public IceSSL::EndpointInfo
 255     {
 256     public:
 257
 258         InfoI(Int to, bool comp, const string& host, Int port) :
 259             IceSSL::EndpointInfo(to, comp, host, port)
 260         {
 261         }
 262
 263         virtual Short
 264         type() const
 265         {
 266             return EndpointType;
 267         }
 268
 269         virtual bool
 270         datagram() const
 271         {
 272             return false;
 273         }
 274
 275         virtual bool
 276         secure() const
 277         {
 278             return true;
 279         }
 280     };
 281 }
 282
 283 Ice::EndpointInfoPtr
 284 IceSSL::EndpointI::getInfo() const
 285 {
 286     return new InfoI(_timeout, _compress, _host, _port);
 287 }
 288
 289 Short
 290 IceSSL::EndpointI::type() const
 291 {
 292     return EndpointType;
 293 }
 294
 295 Int
 296 IceSSL::EndpointI::timeout() const
 297 {
 298     return _timeout;
 299 }
 300
 301 IceInternal::EndpointIPtr
 302 IceSSL::EndpointI::timeout(Int timeout) const
 303 {
 304     if(timeout == _timeout)
 305     {
 306         return const_cast<EndpointI*>(this);
 307     }
 308     else
 309     {
 310         return new EndpointI(_instance, _host, _port, timeout, _connectionId, _compress);
 311     }
 312 }
 313
 314 IceInternal::EndpointIPtr
 315 IceSSL::EndpointI::connectionId(const string& connectionId) const
 316 {
 317     if(connectionId == _connectionId)
 318     {
 319         return const_cast<EndpointI*>(this);
 320     }
 321     else
 322     {
 323         return new EndpointI(_instance, _host, _port, _timeout, connectionId, _compress);
 324     }
 325 }
 326
 327 bool
 328 IceSSL::EndpointI::compress() const
 329 {
 330     return _compress;
 331 }
 332
 333 IceInternal::EndpointIPtr
 334 IceSSL::EndpointI::compress(bool compress) const
 335 {
 336     if(compress == _compress)
 337     {
 338         return const_cast<EndpointI*>(this);
 339     }
 340     else
 341     {
 342         return new EndpointI(_instance, _host, _port, _timeout, _connectionId, compress);
 343     }
 344 }
 345
 346 bool
 347 IceSSL::EndpointI::datagram() const
 348 {
 349     return false;
 350 }
 351
 352 bool
 353 IceSSL::EndpointI::secure() const
 354 {
 355     return true;
 356 }
 357
 358 IceInternal::TransceiverPtr
 359 IceSSL::EndpointI::transceiver(IceInternal::EndpointIPtr& endp) const
 360 {
 361     endp = const_cast<EndpointI*>(this);
 362     return 0;
 363 }
 364
 365 vector<IceInternal::ConnectorPtr>
 366 IceSSL::EndpointI::connectors() const
 367 {
 368     return connectors(IceInternal::getAddresses(_host, _port, _instance->protocolSupport(), true));
 369 }
 370
 371 void
 372 IceSSL::EndpointI::connectors_async(const IceInternal::EndpointI_connectorsPtr& callback) const
 373 {
 374     _instance->endpointHostResolver()->resolve(_host, _port, const_cast<EndpointI*>(this), callback);
 375 }
 376
 377 IceInternal::AcceptorPtr
 378 IceSSL::EndpointI::acceptor(IceInternal::EndpointIPtr& endp, const string& adapterName) const
 379 {
 380     AcceptorI* p = new AcceptorI(_instance, adapterName, _host, _port);
 381     endp = new EndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress);
 382     return p;
 383 }
 384
 385 vector<IceInternal::EndpointIPtr>
 386 IceSSL::EndpointI::expand() const
 387 {
 388     vector<IceInternal::EndpointIPtr> endps;
 389     vector<string> hosts = IceInternal::getHostsForEndpointExpand(_host, _instance->protocolSupport(), false);
 390     if(hosts.empty())
 391     {
 392         endps.push_back(const_cast<EndpointI*>(this));
 393     }
 394     else
 395     {
 396         for(vector<string>::const_iterator p = hosts.begin(); p != hosts.end(); ++p)
 397         {
 398             endps.push_back(new EndpointI(_instance, *p, _port, _timeout, _connectionId, _compress));
 399         }
 400     }
 401     return endps;
 402 }
 403
 404 bool
 405 IceSSL::EndpointI::equivalent(const IceInternal::EndpointIPtr& endpoint) const
 406 {
 407     const EndpointI* sslEndpointI = dynamic_cast<const EndpointI*>(endpoint.get());
 408     if(!sslEndpointI)
 409     {
 410         return false;
 411     }
 412     return sslEndpointI->_host == _host && sslEndpointI->_port == _port;
 413 }
 414
 415 bool
 416 IceSSL::EndpointI::operator==(const Ice::LocalObject& r) const
 417 {
 418     const EndpointI* p = dynamic_cast<const EndpointI*>(&r);
 419     if(!p)
 420     {
 421         return false;
 422     }
 423
 424     if(this == p)
 425     {
 426         return true;
 427     }
 428
 429     if(_host != p->_host)
 430     {
 431         return false;
 432     }
 433
 434     if(_port != p->_port)
 435     {
 436         return false;
 437     }
 438
 439     if(_timeout != p->_timeout)
 440     {
 441         return false;
 442     }
 443
 444     if(_connectionId != p->_connectionId)
 445     {
 446         return false;
 447     }
 448
 449     if(_compress != p->_compress)
 450     {
 451         return false;
 452     }
 453
 454     return true;
 455 }
 456
 457 bool
 458 IceSSL::EndpointI::operator<(const Ice::LocalObject& r) const
 459 {
 460     const EndpointI* p = dynamic_cast<const EndpointI*>(&r);
 461     if(!p)
 462     {
 463         const IceInternal::EndpointI* e = dynamic_cast<const IceInternal::EndpointI*>(&r);
 464         if(!e)
 465         {
 466             return false;
 467         }
 468         return type() < e->type();
 469     }
 470
 471     if(this == p)
 472     {
 473         return false;
 474     }
 475
 476     if(_host < p->_host)
 477     {
 478         return true;
 479     }
 480     else if (p->_host < _host)
 481     {
 482         return false;
 483     }
 484
 485     if(_port < p->_port)
 486     {
 487         return true;
 488     }
 489     else if(p->_port < _port)
 490     {
 491         return false;
 492     }
 493
 494     if(_timeout < p->_timeout)
 495     {
 496         return true;
 497     }
 498     else if(p->_timeout < _timeout)
 499     {
 500         return false;
 501     }
 502
 503     if(_connectionId < p->_connectionId)
 504     {
 505         return true;
 506     }
 507     else if(p->_connectionId < _connectionId)
 508     {
 509         return false;
 510     }
 511
 512     if(!_compress && p->_compress)
 513     {
 514         return true;
 515     }
 516     else if(p->_compress < _compress)
 517     {
 518         return false;
 519     }
 520
 521     return false;
 522 }
 523
 524 Ice::Int
 525 IceSSL::EndpointI::hashInit() const
 526 {
 527     Int h = 0;
 528     IceInternal::hashAdd(h, _host);
 529     IceInternal::hashAdd(h, _port);
 530     IceInternal::hashAdd(h, _timeout);
 531     IceInternal::hashAdd(h, _connectionId);
 532     IceInternal::hashAdd(h, _compress);
 533     return h;
 534 }
 535
 536 vector<IceInternal::ConnectorPtr>
 537 IceSSL::EndpointI::connectors(const vector<struct sockaddr_storage>& addresses) const
 538 {
 539     vector<IceInternal::ConnectorPtr> connectors;
 540     for(unsigned int i = 0; i < addresses.size(); ++i)
 541     {
 542         connectors.push_back(new ConnectorI(_instance, _host, addresses[i], _timeout, _connectionId));
 543     }
 544     return connectors;
 545 }
 546
 547 IceSSL::EndpointFactoryI::EndpointFactoryI(const InstancePtr& instance)
 548     : _instance(instance)
 549 {
 550 }
 551
 552 IceSSL::EndpointFactoryI::~EndpointFactoryI()
 553 {
 554 }
 555
 556 Short
 557 IceSSL::EndpointFactoryI::type() const
 558 {
 559     return EndpointType;
 560 }
 561
 562 string
 563 IceSSL::EndpointFactoryI::protocol() const
 564 {
 565     return "ssl";
 566 }
 567
 568 IceInternal::EndpointIPtr
 569 IceSSL::EndpointFactoryI::create(const string& str, bool oaEndpoint) const
 570 {
 571     return new EndpointI(_instance, str, oaEndpoint);
 572 }
 573
 574 IceInternal::EndpointIPtr
 575 IceSSL::EndpointFactoryI::read(IceInternal::BasicStream* s) const
 576 {
 577     return new EndpointI(_instance, s);
 578 }
 579
 580 void
 581 IceSSL::EndpointFactoryI::destroy()
 582 {
 583     _instance = 0;
 584 }