2008-05-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>

	Rewritten name resolver. Now async DNS can be disabled by 
--async-dns
	option.
	The asynchronous DNS is not capable of IPv6 yet.
	By disabling asynchronous DNS, aria2 is IPv6 enabled 
application, at
	least for HTTP download.
	* src/AbstractCommand.cc
	* src/AbstractCommand.h
	* src/AsyncNameResolver.cc
	* src/AsyncNameResolver.h
	* src/DHTEntryPointNameResolveCommand.cc
	* src/DHTEntryPointNameResolveCommand.h
	* src/DownloadEngine.cc
	* src/DownloadEngine.h
	* src/FtpInitiateConnectionCommand.cc
	* src/FtpInitiateConnectionCommand.h
	* src/HelpItemFactory.cc
	* src/HttpInitiateConnectionCommand.cc
	* src/HttpInitiateConnectionCommand.h
	* src/InitiateConnectionCommand.cc
	* src/InitiateConnectionCommand.h
	* src/Makefile.am
	* src/Makefile.in
	* src/NameResolver.cc
	* src/NameResolver.h
	* src/OptionHandlerFactory.cc
	* src/SocketCore.cc
	* src/SocketCore.h
	* src/Util.cc
	* src/Util.h
	* src/option_processing.cc
	* src/prefs.h
	* src/usage_text.h

1 files changed, 19 insertions, 54 deletions

diff --git a/src/HttpInitiateConnectionCommand.cc b/src/HttpInitiateConnectionCommand.cc
index cb4f35d9..76400187 100644
--- a/src/HttpInitiateConnectionCommand.cc
+++ b/src/HttpInitiateConnectionCommand.cc
@@ -33,7 +33,6 @@
  */
 /* copyright --> */
 #include "HttpInitiateConnectionCommand.h"
-#include "NameResolver.h"
 #include "Request.h"
 #include "DownloadEngine.h"
 #include "HttpConnection.h"
@@ -43,7 +42,6 @@
 #include "HttpProxyRequestCommand.h"
 #include "DlAbortEx.h"
 #include "Option.h"
-#include "Util.h"
 #include "Logger.h"
 #include "Socket.h"
 #include "message.h"
@@ -51,46 +49,24 @@
 
 namespace aria2 {
 
-HttpInitiateConnectionCommand::HttpInitiateConnectionCommand(int cuid,
-							     const RequestHandle& req,
-							     RequestGroup* requestGroup,
-							     DownloadEngine* e):
-  AbstractCommand(cuid, req, requestGroup, e),
-  nameResolver(new NameResolver())
-{
-  setTimeout(e->option->getAsInt(PREF_DNS_TIMEOUT));
-  setStatus(Command::STATUS_ONESHOT_REALTIME);
-  disableReadCheckSocket();
-  disableWriteCheckSocket();
-}
+HttpInitiateConnectionCommand::HttpInitiateConnectionCommand
+(int cuid,
+ const RequestHandle& req,
+ RequestGroup* requestGroup,
+ DownloadEngine* e):
+  InitiateConnectionCommand(cuid, req, requestGroup, e) {}
 
-HttpInitiateConnectionCommand::~HttpInitiateConnectionCommand() {
-#ifdef ENABLE_ASYNC_DNS
-  disableNameResolverCheck(nameResolver);
-#endif // ENABLE_ASYNC_DNS
-}
+HttpInitiateConnectionCommand::~HttpInitiateConnectionCommand() {}
 
-bool HttpInitiateConnectionCommand::executeInternal() {
-  std::string hostname;
-  if(useProxy()) {
-    hostname = e->option->get(PREF_HTTP_PROXY_HOST);
-  } else {
-    hostname = req->getHost();
-  }
-  if(!Util::isNumbersAndDotsNotation(hostname)) {
-    if(resolveHostname(hostname, nameResolver)) {
-      hostname = nameResolver->getAddrString();
-    } else {
-      e->commands.push_back(this);
-      return false;
-    }
-  }
+Command* HttpInitiateConnectionCommand::createNextCommand
+(const std::deque<std::string>& resolvedAddresses)
+{
   Command* command;
-  if(useProxy()) {
+  if(useHTTPProxy()) {
     logger->info(MSG_CONNECTING_TO_SERVER, cuid,
 		 e->option->get(PREF_HTTP_PROXY_HOST).c_str(),
 		 e->option->getAsInt(PREF_HTTP_PROXY_PORT));
-    socket->establishConnection(hostname,
+    socket->establishConnection(resolvedAddresses.front(),
 				e->option->getAsInt(PREF_HTTP_PROXY_PORT));
     if(useProxyTunnel()) {
       command = new HttpProxyRequestCommand(cuid, req, _requestGroup, e, socket);
@@ -104,12 +80,11 @@ bool HttpInitiateConnectionCommand::executeInternal() {
     }
   } else {
     SharedHandle<SocketCore> pooledSocket =
-      e->popPooledSocket(hostname, req->getPort());
-
+      e->popPooledSocket(resolvedAddresses, req->getPort());
     if(pooledSocket.isNull()) {
       logger->info(MSG_CONNECTING_TO_SERVER, cuid, req->getHost().c_str(),
 		   req->getPort());
-      socket->establishConnection(hostname, req->getPort());
+      socket->establishConnection(resolvedAddresses.front(), req->getPort());
     } else {
       socket = pooledSocket;
     }
@@ -117,27 +92,17 @@ bool HttpInitiateConnectionCommand::executeInternal() {
     command = new HttpRequestCommand(cuid, req, _requestGroup, httpConnection,
 				     e, socket);
   }
-  e->commands.push_back(command);
-  return true;
-}
-
-bool HttpInitiateConnectionCommand::useProxy() {
-  return e->option->get(PREF_HTTP_PROXY_ENABLED) == V_TRUE;
+  return command;
 }
 
-bool HttpInitiateConnectionCommand::useProxyGet() {
+bool HttpInitiateConnectionCommand::useProxyGet() const
+{
   return e->option->get(PREF_HTTP_PROXY_METHOD) == V_GET;
 }
 
-bool HttpInitiateConnectionCommand::useProxyTunnel() {
+bool HttpInitiateConnectionCommand::useProxyTunnel() const
+{
   return e->option->get(PREF_HTTP_PROXY_METHOD) == V_TUNNEL;
 }
 
-#ifdef ENABLE_ASYNC_DNS
-bool HttpInitiateConnectionCommand::nameResolveFinished() const {
-  return nameResolver->getStatus() ==  NameResolver::STATUS_SUCCESS ||
-    nameResolver->getStatus() == NameResolver::STATUS_ERROR;
-}
-#endif // ENABLE_ASYNC_DNS
-
 } // namespace aria2