bool ConnectionCache::release_connection(const ConnectionKey& key,
connection_type* connection)
{
INET_TRACE ("ConnectionCache::release_connection");
INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::release_connection - ")
ACE_TEXT ("releasing connection\n")));
ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
guard_,
this->lock_,
false));
ConnectionCacheValue cacheval;
if (this->find_connection (key, cacheval) &&
cacheval.connection () == connection &&
cacheval.state () == ConnectionCacheValue::CST_BUSY)
{
cacheval.state (ConnectionCacheValue::CST_IDLE);
if (this->set_connection (key, cacheval))
{
// signal other threads about free connection
this->condition_.broadcast ();
return true;
}
else
{
INET_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("ConnectionCache::release_connection - ")
ACE_TEXT ("failed to release connection entry")));
return false;
}
}
else
return false;
}
bool Response::read(istream& str)
{
ACE_CString version;
ACE_CString status;
ACE_CString reason;
int ch = str.peek ();
if (ch == eof_)
{
str.get (); // skip to eof
return false;
}
// skip whitespace
while (ACE_OS::ace_isspace (str.peek ()))
{
str.get ();
}
// get version
ch = this->read_ws_field (str, version, MAX_VERSION_LENGTH);
if (ch == eof_ || !ACE_OS::ace_isspace (ch))
return false; // invalid HTTP version string
// skip whitespace
while (ACE_OS::ace_isspace (str.peek ()))
{
str.get ();
}
// get status
ch = this->read_ws_field (str, status, MAX_STATUS_LENGTH);
if (ch == eof_ || !ACE_OS::ace_isspace (ch))
return false; // invalid HTTP status code
// skip whitespace
while (ACE_OS::ace_isspace (str.peek ()))
{
str.get ();
}
// get reason
ch = this->read_field (str, reason, MAX_REASON_LENGTH, '\r');
if (ch == '\r')
ch = str.get (); // get lf
if (ch != '\n')
return false; // HTTP reason string too long
INET_DEBUG (6, (LM_DEBUG, DLINFO
ACE_TEXT ("ACE_INet_HTTP: <-- %C %C %C\n"),
version.c_str (),
status.c_str (),
reason.c_str()));
// get header lines
if (!Header::read (str))
return false;
// skip empty line
ch = str.get ();
while (ch != '\n' && ch != eof_)
ch = str.get ();
this->set_version(version);
this->status_.set_status (status);
this->status_.set_reason (reason);
return true;
}
SessionFactory_Impl::SessionFactory_Impl ()
{
INET_DEBUG (6, (LM_INFO, DLINFO
ACE_TEXT ("HTTP_SessionFactory_Impl::ctor - ")
ACE_TEXT ("registering session factory for scheme [%C]\n"),
URL::protocol ().c_str ()));
SessionFactoryRegistry::instance ().register_session_factory (URL::protocol (), this);
}
void SSL_CertificateAcceptor::handle_certificate_failure (SSL_CertificateCallbackArg& arg)
{
INET_DEBUG (3, (LM_INFO, DLINFO
ACE_TEXT ("SSL_CertificateAcceptor::handle_certificate_failure - ")
ACE_TEXT ("ignored certificate verification error: %C\n"),
arg.error_message ().c_str ()));
arg.ignore_error (true);
}
bool HeaderBase::read(std::istream& str)
{
ACE_CString name (64, '\0');
ACE_CString value (128, '\0');
int ch = str.peek ();
while (ch != eof_ && ch != '\r' && ch != '\n')
{
name.fast_clear ();
value.fast_clear ();
// parse name
ch = this->read_field (str, name, MAX_NAME_LENGTH, ':');
if (ch == '\n')
{
ch = str.get ();
continue; // ignore invalid headers
}
if (ch != ':')
{
return false; // name too long/missing colon; cannot continue
}
// skip leading whitespace before next field
while (ACE_OS::ace_isspace (str.peek ()))
{
ch = str.get ();
}
// parse value
ch = this->read_field (str, value, MAX_VALUE_LENGTH, '\r');
if (ch == '\r')
ch = str.get (); // get lf
if (ch != '\n')
return false; // value too long/no crlf found; cannot continue
// followup lines starting with ws are continuations of the value
// and must be appended
ch = str.peek ();
while (ch == ' ' || ch == '\t')
{
ch = this->read_field (str, value, MAX_VALUE_LENGTH, '\r');
if (ch == '\r')
ch = str.get (); // get lf
if (ch != '\n')
return false; // multiline value too long/no crlf; cannot continue
ch = str.peek ();
}
this->add (name, value);
INET_DEBUG (9, (LM_DEBUG, DLINFO
ACE_TEXT ("ACE_INet_HTTP: <-+ %C: %C\n"),
name.c_str (),
value.c_str ()));
}
return true;
}
void HeaderBase::write(std::ostream& str) const
{
TNVMap::ITERATOR it (const_cast<TNVMap&> (this->header_values_));
for (it.first (); !it.done () ;it.advance ())
{
str << (*it).first ().c_str () << ": " << (*it).second ().c_str () << "\r\n";
INET_DEBUG (9, (LM_DEBUG, DLINFO
ACE_TEXT ("ACE_INet_HTTP: +-> %C: %C\n"),
(*it).first ().c_str (),
(*it).second ().c_str ()));
}
}
void Request::write(std::ostream& str) const
{
str << this->method_.c_str () << " " << this->uri_.c_str () << " " << this->get_version ().c_str () << "\r\n";
INET_DEBUG (6, (LM_DEBUG, DLINFO
ACE_TEXT ("ACE_INet_HTTP: --> %C %C %C\n"),
this->method_.c_str (),
this->uri_.c_str (),
this->get_version ().c_str ()));
Header::write (str);
str << "\r\n";
}
void Request::write(std::ostream& str) const
{
str << this->command_.c_str ();
if (!this->args_.empty ())
str << ' ' << this->args_.c_str ();
str << "\r\n";
INET_DEBUG (6, (LM_DEBUG, DLINFO
ACE_TEXT ("ACE_INet_FTP: --> %C %C\n"),
this->command_.c_str (),
this->command_ == FTP_PASS ?
"***" : this->args_.c_str ()));
}
bool ConnectionCache::claim_connection(const ConnectionKey& key,
connection_type*& connection,
const factory_type& connection_factory,
bool wait)
{
INET_TRACE ("ConnectionCache::claim_connection");
while (1)
{
bool create_connection = false;
ConnectionCacheValue::State state = ConnectionCacheValue::CST_NONE;
do
{
ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
guard_,
this->lock_,
false));
if (this->claim_existing_connection (key, connection, state))
{
INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("%P|%t) ConnectionCache::claim_connection - ")
ACE_TEXT ("successfully claimed existing connection\n")));
return true;
}
if ((state == ConnectionCacheValue::CST_BUSY ||
state == ConnectionCacheValue::CST_INIT) && !wait)
return false;
if (state == ConnectionCacheValue::CST_CLOSED ||
state == ConnectionCacheValue::CST_NONE)
{
if (!this->set_connection (key, ConnectionCacheValue ()))
{
INET_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("ConnectionCache::claim_connection - ")
ACE_TEXT ("failed to initialize connection entry")));
return false;
}
create_connection = true;
}
else
{
INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::claim_connection - ")
ACE_TEXT ("waiting for connection to become available\n")));
// wait for connection to become ready/free
if (this->condition_.wait () != 0)
{
INET_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("(%P|%t) ConnectionCache::claim_connection - ")
ACE_TEXT ("error waiting for connection condition (%p)\n")));
return false;
}
INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::claim_connection - ")
ACE_TEXT ("awoken and retrying to claim connection\n")));
}
}
while (0);
if (create_connection)
{
connection = connection_factory.create_connection (key);
if (connection)
{
INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::claim_connection - ")
ACE_TEXT ("successfully created new connection\n")));
ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
guard_,
this->lock_,
false));
ConnectionCacheValue cacheval (connection);
cacheval.state (ConnectionCacheValue::CST_BUSY);
return this->set_connection (key, cacheval);
}
else
return false;
}
}
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv [])
{
ACE_Auto_Ptr<std::ofstream> fout;
std::ostream* sout = &std::cout;
if (!parse_args (argc, argv))
{
return 1;
}
#if defined (ACE_HAS_SSL) && ACE_HAS_SSL == 1
ACE::HTTPS::Context::set_default_ssl_mode (ssl_mode);
ACE::HTTPS::Context::set_default_verify_mode (verify_peer);
ACE::HTTPS::Context::instance ().use_default_ca ();
if (!private_key.empty ())
{
if (certificate.empty ())
{
std::cerr << "ERROR: private key file [" << private_key << "] requires certificate file to be specified." << std::endl;
return 1;
}
if (!ACE::HTTPS::Context::instance ().set_key_files (private_key.c_str (), certificate.c_str ()))
{
std::cerr << "ERROR: failed to set private key [" << private_key << "]." << std::endl;
return 1;
}
}
if (!ca_location.empty ())
{
INET_DEBUG (6, (LM_INFO, DLINFO ACE_TEXT ("loading trusted CA [%C]\n"), ca_location.c_str ()));
if (!ACE::HTTPS::Context::instance ().load_trusted_ca (ca_location.c_str ()))
{
std::cerr << "ERROR: failed to load trusted CA from [" << ca_location << "]." << std::endl;
return 1;
}
INET_DEBUG (6, (LM_INFO, DLINFO ACE_TEXT ("loaded [%d] trusted CA\n"), ACE::HTTPS::Context::instance ().has_trusted_ca ()));
}
if (ignore_verify)
ACE::INet::SSL_CallbackManager::instance ()->set_certificate_callback (new ACE::INet::SSL_CertificateAcceptor);
#endif
std::cout << "Starting..." << std::endl;
if (!url.empty ())
{
if (!outfile.empty ())
{
fout.reset (new std::ofstream (outfile.c_str (), std::ios_base::binary|std::ios_base::out));
if (!*fout)
{
std::cerr << "Failed to open output file : " << outfile.c_str () << std::endl;
return 1;
}
sout = fout.get ();
}
std::cout << "Parsing url [" << url.c_str () << "]" << std::endl;
ACE_Auto_Ptr<ACE::INet::URL_Base> url_safe (ACE::INet::URL_Base::create_from_string (url));
if (url_safe.get () == 0 || url != url_safe->to_string ())
{
std::cerr << "Failed parsing url [" << url << "]" << std::endl;
std::cerr << "\tresult = " << (url_safe.get () == 0 ? "(null)" : url_safe->to_string ().c_str ()) << std::endl;
return 1;
}
ACE::HTTP::URL& http_url = *dynamic_cast<ACE::HTTP::URL*> (url_safe.get ());
if (!proxy_hostname.empty ())
{
std::cout << "Setting proxy: " << proxy_hostname.c_str () << ':' << proxy_port << std::endl;
http_url.set_proxy (proxy_hostname, proxy_port);
}
std::cout << "Opening url...";
My_HTTP_RequestHandler my_rh;
ACE::INet::URLStream urlin = http_url.open (my_rh);
if (urlin)
{
std::cout << "Received response "
<< (int)my_rh.response ().get_status ().get_status ()
<< " "
<< my_rh.response ().get_status ().get_reason ().c_str ()
<< std::endl;
if (my_rh.response ().get_status ().is_ok ())
{
std::cout << "Length: ";
if (my_rh.response ().get_content_length () != ACE::HTTP::Response::UNKNOWN_CONTENT_LENGTH)
std::cout << my_rh.response ().get_content_length () << " [";
else
std::cout << "(unknown) [";
if (my_rh.response ().get_content_type () != ACE::HTTP::Response::UNKNOWN_CONTENT_TYPE)
std::cout << my_rh.response ().get_content_type ().c_str ();
else
std::cout << "(unknown)";
std::cout << "]" << std::endl;
}
std::cout << "Saving to: ";
if (!outfile.empty ())
std::cout << '\'' << outfile.c_str () << '\'' << std::endl;
else
std::cout << "(stdout)" << std::endl;
(*sout) << urlin->rdbuf ();
sout->flush ();
}
}
else
{
std::cerr << "ERROR: No URL specified!" << std::endl;
usage ();
return 1;
}
std::cout << "Done" << std::endl;
return 0;
}
