fix connect timeoute introduced by pull request#11

melode11 · melode11 · commit df8b2291c877 · 2015-05-06T23:30:35.000+08:00
diff --git a/src/internal/sio_client_impl.cpp b/src/internal/sio_client_impl.cpp
@@ -19,6 +19,7 @@
 #endif
 
 using boost::posix_time::milliseconds;
+using namespace std;
 
 namespace sio
 {
@@ -60,7 +61,7 @@ namespace sio
         sync_close();
     }
     
-    void client_impl::connect(const std::string& uri, const std::map<string,string>& query)
+    void client_impl::connect(const string& uri, const map<string,string>& query)
     {
         if(m_reconn_timer)
         {
@@ -87,25 +88,25 @@ namespace sio
         m_base_url = uri;
         m_reconn_made = 0;
 
-        std::string queryString;
-        for(std::map<std::string,std::string>::const_iterator it=query.begin();it!=query.end();++it){
-            queryString.append("&");
-            queryString.append(it->first);
-            queryString.append("=");
-            queryString.append(it->second);
+        string query_str;
+        for(map<string,string>::const_iterator it=query.begin();it!=query.end();++it){
+            query_str.append("&");
+            query_str.append(it->first);
+            query_str.append("=");
+            query_str.append(it->second);
         }
-        m_query_string=queryString;
+        m_query_string=move(query_str);
 
         this->reset_states();
-        m_client.get_io_service().dispatch(lib::bind(&client_impl::connect_impl,this,uri,queryString));
-        m_network_thread.reset(new std::thread(lib::bind(&client_impl::run_loop,this)));//uri lifecycle?
+        m_client.get_io_service().dispatch(lib::bind(&client_impl::connect_impl,this,uri,m_query_string));
+        m_network_thread.reset(new thread(lib::bind(&client_impl::run_loop,this)));//uri lifecycle?
 
     }
 
-    socket::ptr const& client_impl::socket(std::string const& nsp)
+    socket::ptr const& client_impl::socket(string const& nsp)
     {
-        std::lock_guard<std::mutex> guard(m_socket_mutex);
-        std::string aux;
+        lock_guard<mutex> guard(m_socket_mutex);
+        string aux;
         if(nsp == "")
         {
             aux = "/";
@@ -127,7 +128,7 @@ namespace sio
         }
         else
         {
-            std::pair<const std::string, socket::ptr> p(aux,std::shared_ptr<sio::socket>(new sio::socket(this,aux)));
+            pair<const string, socket::ptr> p(aux,shared_ptr<sio::socket>(new sio::socket(this,aux)));
             return (m_sockets.insert(p).first)->second;
         }
     }
@@ -157,9 +158,9 @@ namespace sio
         m_packet_mgr.encode(p);
     }
 
-    void client_impl::remove_socket(std::string const& nsp)
+    void client_impl::remove_socket(string const& nsp)
     {
-        std::lock_guard<std::mutex> guard(m_socket_mutex);
+        lock_guard<mutex> guard(m_socket_mutex);
         auto it = m_sockets.find(nsp);
         if(it!= m_sockets.end())
         {
@@ -172,12 +173,12 @@ namespace sio
         return m_client.get_io_service();
     }
 
-    void client_impl::on_socket_closed(std::string const& nsp)
+    void client_impl::on_socket_closed(string const& nsp)
     {
         if(m_socket_close_listener)m_socket_close_listener(nsp);
     }
 
-    void client_impl::on_socket_opened(std::string const& nsp)
+    void client_impl::on_socket_opened(string const& nsp)
     {
         if(m_socket_open_listener)m_socket_open_listener(nsp);
     }
@@ -192,11 +193,11 @@ namespace sio
                                   "run loop end");
     }
 
-    void client_impl::connect_impl(const std::string& uri, const std::string& queryString)
+    void client_impl::connect_impl(const string& uri, const string& queryString)
     {
         do{
             websocketpp::uri uo(uri);
-            std::ostringstream ss;
+            ostringstream ss;
 
             if (m_sid.size()==0) {
                 ss<<"ws://"<<uo.get_host()<<":"<<uo.get_port()<<"/socket.io/?EIO=4&transport=websocket&t="<<time(NULL)<<queryString;
@@ -223,17 +224,17 @@ namespace sio
         }
     }
 
-    void client_impl::close_impl(close::status::value const& code,std::string const& reason)
+    void client_impl::close_impl(close::status::value const& code,string const& reason)
     {
-        LOG("Close by reason:"<<reason << std::endl);
+        LOG("Close by reason:"<<reason << endl);
         if(m_reconn_timer)
         {
             m_reconn_timer->cancel();
             m_reconn_timer.reset();
         }
         if (m_con.expired())
         {
-            std::cerr << "Error: No active session" << std::endl;
+            cerr << "Error: No active session" << endl;
         }
         else
         {
@@ -242,7 +243,7 @@ namespace sio
         }
     }
 
-    void client_impl::send_impl(std::shared_ptr<const std::string> const& payload_ptr,frame::opcode::value opcode)
+    void client_impl::send_impl(shared_ptr<const string> const& payload_ptr,frame::opcode::value opcode)
     {
         if(m_con_state == con_opened)
         {
@@ -257,7 +258,7 @@ namespace sio
             m_client.send(m_con,*payload_ptr,opcode,ec);
             if(ec)
             {
-                std::cerr<<"Send failed,reason:"<< ec.message()<<std::endl;
+                cerr<<"Send failed,reason:"<< ec.message()<<endl;
             }
         }
     }
@@ -266,7 +267,7 @@ namespace sio
     {
         if(ec || m_con.expired())
         {
-            LOG("ping exit,con is expired?"<<m_con.expired()<<",ec:"<<ec.message()<<std::endl);
+            LOG("ping exit,con is expired?"<<m_con.expired()<<",ec:"<<ec.message()<<endl);
             return;
         }
         packet p(packet::frame_ping);
@@ -297,7 +298,7 @@ namespace sio
         {
             return;
         }
-        LOG("Pong timeout"<<std::endl);
+        LOG("Pong timeout"<<endl);
         m_client.get_io_service().dispatch(lib::bind(&client_impl::close_impl, this,close::status::policy_violation,"Pong timeout"));
     }
 
@@ -312,7 +313,7 @@ namespace sio
             m_con_state = con_opening;
             m_reconn_made++;
             this->reset_states();
-            LOG("Reconnecting..."<<std::endl);
+            LOG("Reconnecting..."<<endl);
             if(m_reconnecting_listener) m_reconnecting_listener();
             m_client.get_io_service().dispatch(lib::bind(&client_impl::connect_impl,this,m_base_url,m_query_string));
         }
@@ -324,9 +325,9 @@ namespace sio
         return min<unsigned>(static_cast<unsigned>(m_reconn_delay * pow(1.5,m_reconn_made)),m_reconn_delay_max);
     }
 
-    socket::ptr client_impl::get_socket_locked(std::string const& nsp)
+    socket::ptr client_impl::get_socket_locked(string const& nsp)
     {
-        std::lock_guard<std::mutex> guard(m_socket_mutex);
+        lock_guard<mutex> guard(m_socket_mutex);
         auto it = m_sockets.find(nsp);
         if(it != m_sockets.end())
         {
@@ -340,9 +341,9 @@ namespace sio
 
     void client_impl::sockets_invoke_void(void (sio::socket::*fn)(void))
     {
-        std::map<const std::string,socket::ptr> socks;
+        map<const string,socket::ptr> socks;
         {
-            std::lock_guard<std::mutex> guard(m_socket_mutex);
+            lock_guard<mutex> guard(m_socket_mutex);
             socks.insert(m_sockets.begin(),m_sockets.end());
         }
         for (auto it = socks.begin(); it!=socks.end(); ++it) {
@@ -355,10 +356,10 @@ namespace sio
         m_con.reset();
         m_con_state = con_closed;
         this->sockets_invoke_void(&sio::socket::on_disconnect);
-        LOG("Connection failed." << std::endl);
+        LOG("Connection failed." << endl);
         if(m_reconn_made<m_reconn_attempts)
         {
-            LOG("Reconnect for attempt:"<<m_reconn_made<<std::endl);
+            LOG("Reconnect for attempt:"<<m_reconn_made<<endl);
             unsigned delay = this->next_delay();
             if(m_reconnect_listener) m_reconnect_listener(m_reconn_made,delay);
             m_reconn_timer.reset(new boost::asio::deadline_timer(m_client.get_io_service()));
@@ -374,23 +375,24 @@ namespace sio
     
     void client_impl::on_open(connection_hdl con)
     {
-        LOG("Connected." << std::endl);
+        LOG("Connected." << endl);
         m_con_state = con_opened;
         m_con = con;
         m_reconn_made = 0;
         this->sockets_invoke_void(&sio::socket::on_open);
+        this->socket("");
         if(m_open_listener)m_open_listener();
     }
     
     void client_impl::on_close(connection_hdl con)
     {
-        LOG("Client Disconnected." << std::endl);
+        LOG("Client Disconnected." << endl);
         m_con_state = con_closed;
         lib::error_code ec;
         close::status::value code = close::status::normal;
         client_type::connection_ptr conn_ptr  = m_client.get_con_from_hdl(con, ec);
         if (ec) {
-            LOG("OnClose get conn failed"<<ec<<std::endl);
+            LOG("OnClose get conn failed"<<ec<<endl);
         }
         else
         {
@@ -410,7 +412,7 @@ namespace sio
             this->sockets_invoke_void(&sio::socket::on_disconnect);
             if(m_reconn_made<m_reconn_attempts)
             {
-                LOG("Reconnect for attempt:"<<m_reconn_made<<std::endl);
+                LOG("Reconnect for attempt:"<<m_reconn_made<<endl);
                 unsigned delay = this->next_delay();
                 if(m_reconnect_listener) m_reconnect_listener(m_reconn_made,delay);
                 m_reconn_timer.reset(new boost::asio::deadline_timer(m_client.get_io_service()));
@@ -447,15 +449,15 @@ namespace sio
             const map<string,message::ptr>* values = &(obj_ptr->get_map());
             auto it = values->find("sid");
             if (it!= values->end()) {
-                m_sid = std::static_pointer_cast<string_message>(it->second)->get_string();
+                m_sid = static_pointer_cast<string_message>(it->second)->get_string();
             }
             else
             {
                 goto failed;
             }
             it = values->find("pingInterval");
             if (it!= values->end()&&it->second->get_flag() == message::flag_integer) {
-                m_ping_interval = (unsigned)std::static_pointer_cast<int_message>(it->second)->get_int();
+                m_ping_interval = (unsigned)static_pointer_cast<int_message>(it->second)->get_int();
             }
             else
             {
@@ -464,7 +466,7 @@ namespace sio
             it = values->find("pingTimeout");
 
             if (it!=values->end()&&it->second->get_flag() == message::flag_integer) {
-                m_ping_timeout = (unsigned) std::static_pointer_cast<int_message>(it->second)->get_int();
+                m_ping_timeout = (unsigned) static_pointer_cast<int_message>(it->second)->get_int();
             }
             else
             {
@@ -474,9 +476,9 @@ namespace sio
             m_ping_timer.reset(new boost::asio::deadline_timer(m_client.get_io_service()));
             boost::system::error_code ec;
             m_ping_timer->expires_from_now(milliseconds(m_ping_interval), ec);
-            if(ec)LOG("ec:"<<ec.message()<<std::endl);
+            if(ec)LOG("ec:"<<ec.message()<<endl);
             m_ping_timer->async_wait(lib::bind(&client_impl::ping,this,lib::placeholders::_1));
-            LOG("On handshake,sid:"<<m_sid<<",ping interval:"<<m_ping_interval<<",ping timeout"<<m_ping_timeout<<std::endl);
+            LOG("On handshake,sid:"<<m_sid<<",ping interval:"<<m_ping_interval<<",ping timeout"<<m_ping_timeout<<endl);
             return;
         }
 failed:
@@ -521,13 +523,13 @@ namespace sio
     
     void client_impl::on_encode(bool isBinary,shared_ptr<const string> const& payload)
     {
-        LOG("encoded payload length:"<<payload->length()<<std::endl);
+        LOG("encoded payload length:"<<payload->length()<<endl);
         m_client.get_io_service().dispatch(lib::bind(&client_impl::send_impl,this,payload,isBinary?frame::opcode::binary:frame::opcode::text));
     }
     
     void client_impl::clear_timers()
     {
-        LOG("clear timers"<<std::endl);
+        LOG("clear timers"<<endl);
         boost::system::error_code ec;
         if(m_ping_timeout_timer)
         {
diff --git a/src/internal/sio_client_impl.h b/src/internal/sio_client_impl.h
@@ -87,7 +87,7 @@ namespace sio
         }
         
         // Client Functions - such as send, etc.
-        void connect(const std::string& uri, const std::map<string, string>& queryString);
+        void connect(const std::string& uri, const std::map<std::string, std::string>& queryString);
         
         sio::socket::ptr const& socket(const std::string& nsp);
         
diff --git a/src/sio_socket.cpp b/src/sio_socket.cpp
@@ -265,6 +265,10 @@ namespace sio
     void socket::impl::send_connect()
     {
         NULL_GUARD(m_client);
+        if(m_nsp == "/")
+        {
+            return;
+        }
         packet p(packet::type_connect,m_nsp);
         m_client->send(p);
         m_connection_timer.reset(new boost::asio::deadline_timer(m_client->get_io_service()));
@@ -469,8 +473,9 @@ namespace sio
             return;
         }
         m_connection_timer.reset();
-        LOG("Connection timeout"<<std::endl);
-        this->on_disconnect();
+        LOG("Connection timeout,close socket."<<std::endl);
+        //Should close socket if no connected message arrive.Otherwise we'll never ask for open again.
+        this->on_close();
     }
     
     void socket::impl::send_packet(sio::packet &p)

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@`
`19`	`19`	`#endif`
`20`	`20`
`21`	`21`	`using boost::posix_time::milliseconds;`
	`22`	`+using namespace std;`
`22`	`23`
`23`	`24`	`namespace sio`
`24`	`25`	`{`
`@@ -60,7 +61,7 @@ namespace sio`
`60`	`61`	`sync_close();`
`61`	`62`	`}`
`62`	`63`
`63`		`- void client_impl::connect(const std::string& uri, const std::map<string,string>& query)`
	`64`	`+ void client_impl::connect(const string& uri, const map<string,string>& query)`
`64`	`65`	`{`
`65`	`66`	`if(m_reconn_timer)`
`66`	`67`	`{`
`@@ -87,25 +88,25 @@ namespace sio`
`87`	`88`	`m_base_url = uri;`
`88`	`89`	`m_reconn_made = 0;`
`89`	`90`
`90`		`- std::string queryString;`
`91`		`- for(std::map<std::string,std::string>::const_iterator it=query.begin();it!=query.end();++it){`
`92`		`- queryString.append("&");`
`93`		`- queryString.append(it->first);`
`94`		`- queryString.append("=");`
`95`		`- queryString.append(it->second);`
	`91`	`+ string query_str;`
	`92`	`+ for(map<string,string>::const_iterator it=query.begin();it!=query.end();++it){`
	`93`	`+ query_str.append("&");`
	`94`	`+ query_str.append(it->first);`
	`95`	`+ query_str.append("=");`
	`96`	`+ query_str.append(it->second);`
`96`	`97`	`}`
`97`		`- m_query_string=queryString;`
	`98`	`+ m_query_string=move(query_str);`
`98`	`99`
`99`	`100`	`this->reset_states();`
`100`		`- m_client.get_io_service().dispatch(lib::bind(&client_impl::connect_impl,this,uri,queryString));`
`101`		`- m_network_thread.reset(new std::thread(lib::bind(&client_impl::run_loop,this)));//uri lifecycle?`
	`101`	`+ m_client.get_io_service().dispatch(lib::bind(&client_impl::connect_impl,this,uri,m_query_string));`
	`102`	`+ m_network_thread.reset(new thread(lib::bind(&client_impl::run_loop,this)));//uri lifecycle?`
`102`	`103`
`103`	`104`	`}`
`104`	`105`
`105`		`- socket::ptr const& client_impl::socket(std::string const& nsp)`
	`106`	`+ socket::ptr const& client_impl::socket(string const& nsp)`
`106`	`107`	`{`
`107`		`- std::lock_guard<std::mutex> guard(m_socket_mutex);`
`108`		`- std::string aux;`
	`108`	`+ lock_guard<mutex> guard(m_socket_mutex);`
	`109`	`+ string aux;`
`109`	`110`	`if(nsp == "")`
`110`	`111`	`{`
`111`	`112`	`aux = "/";`
`@@ -127,7 +128,7 @@ namespace sio`
`127`	`128`	`}`
`128`	`129`	`else`
`129`	`130`	`{`
`130`		`- std::pair<const std::string, socket::ptr> p(aux,std::shared_ptr<sio::socket>(new sio::socket(this,aux)));`
	`131`	`+ pair<const string, socket::ptr> p(aux,shared_ptr<sio::socket>(new sio::socket(this,aux)));`
`131`	`132`	`return (m_sockets.insert(p).first)->second;`
`132`	`133`	`}`
`133`	`134`	`}`
`@@ -157,9 +158,9 @@ namespace sio`
`157`	`158`	`m_packet_mgr.encode(p);`
`158`	`159`	`}`
`159`	`160`
`160`		`- void client_impl::remove_socket(std::string const& nsp)`
	`161`	`+ void client_impl::remove_socket(string const& nsp)`
`161`	`162`	`{`
`162`		`- std::lock_guard<std::mutex> guard(m_socket_mutex);`
	`163`	`+ lock_guard<mutex> guard(m_socket_mutex);`
`163`	`164`	`auto it = m_sockets.find(nsp);`
`164`	`165`	`if(it!= m_sockets.end())`
`165`	`166`	`{`
`@@ -172,12 +173,12 @@ namespace sio`
`172`	`173`	`return m_client.get_io_service();`
`173`	`174`	`}`
`174`	`175`
`175`		`- void client_impl::on_socket_closed(std::string const& nsp)`
	`176`	`+ void client_impl::on_socket_closed(string const& nsp)`
`176`	`177`	`{`
`177`	`178`	`if(m_socket_close_listener)m_socket_close_listener(nsp);`
`178`	`179`	`}`
`179`	`180`
`180`		`- void client_impl::on_socket_opened(std::string const& nsp)`
	`181`	`+ void client_impl::on_socket_opened(string const& nsp)`
`181`	`182`	`{`
`182`	`183`	`if(m_socket_open_listener)m_socket_open_listener(nsp);`
`183`	`184`	`}`
`@@ -192,11 +193,11 @@ namespace sio`
`192`	`193`	`"run loop end");`
`193`	`194`	`}`
`194`	`195`
`195`		`- void client_impl::connect_impl(const std::string& uri, const std::string& queryString)`
	`196`	`+ void client_impl::connect_impl(const string& uri, const string& queryString)`
`196`	`197`	`{`
`197`	`198`	`do{`
`198`	`199`	`websocketpp::uri uo(uri);`
`199`		`- std::ostringstream ss;`
	`200`	`+ ostringstream ss;`
`200`	`201`
`201`	`202`	`if (m_sid.size()==0) {`
`202`	`203`	`ss<<"ws://"<<uo.get_host()<<":"<<uo.get_port()<<"/socket.io/?EIO=4&transport=websocket&t="<<time(NULL)<<queryString;`
`@@ -223,17 +224,17 @@ namespace sio`
`223`	`224`	`}`
`224`	`225`	`}`
`225`	`226`
`226`		`- void client_impl::close_impl(close::status::value const& code,std::string const& reason)`
	`227`	`+ void client_impl::close_impl(close::status::value const& code,string const& reason)`
`227`	`228`	`{`
`228`		`- LOG("Close by reason:"<<reason << std::endl);`
	`229`	`+ LOG("Close by reason:"<<reason << endl);`
`229`	`230`	`if(m_reconn_timer)`
`230`	`231`	`{`
`231`	`232`	`m_reconn_timer->cancel();`
`232`	`233`	`m_reconn_timer.reset();`
`233`	`234`	`}`
`234`	`235`	`if (m_con.expired())`
`235`	`236`	`{`
`236`		`- std::cerr << "Error: No active session" << std::endl;`
	`237`	`+ cerr << "Error: No active session" << endl;`
`237`	`238`	`}`
`238`	`239`	`else`
`239`	`240`	`{`
`@@ -242,7 +243,7 @@ namespace sio`
`242`	`243`	`}`
`243`	`244`	`}`
`244`	`245`
`245`		`- void client_impl::send_impl(std::shared_ptr<const std::string> const& payload_ptr,frame::opcode::value opcode)`
	`246`	`+ void client_impl::send_impl(shared_ptr<const string> const& payload_ptr,frame::opcode::value opcode)`
`246`	`247`	`{`
`247`	`248`	`if(m_con_state == con_opened)`
`248`	`249`	`{`
`@@ -257,7 +258,7 @@ namespace sio`
`257`	`258`	`m_client.send(m_con,*payload_ptr,opcode,ec);`
`258`	`259`	`if(ec)`
`259`	`260`	`{`
`260`		`- std::cerr<<"Send failed,reason:"<< ec.message()<<std::endl;`
	`261`	`+ cerr<<"Send failed,reason:"<< ec.message()<<endl;`
`261`	`262`	`}`
`262`	`263`	`}`
`263`	`264`	`}`
`@@ -266,7 +267,7 @@ namespace sio`
`266`	`267`	`{`
`267`	`268`	`if(ec \|\| m_con.expired())`
`268`	`269`	`{`
`269`		`- LOG("ping exit,con is expired?"<<m_con.expired()<<",ec:"<<ec.message()<<std::endl);`
	`270`	`+ LOG("ping exit,con is expired?"<<m_con.expired()<<",ec:"<<ec.message()<<endl);`
`270`	`271`	`return;`
`271`	`272`	`}`
`272`	`273`	`packet p(packet::frame_ping);`
`@@ -297,7 +298,7 @@ namespace sio`
`297`	`298`	`{`
`298`	`299`	`return;`
`299`	`300`	`}`
`300`		`- LOG("Pong timeout"<<std::endl);`
	`301`	`+ LOG("Pong timeout"<<endl);`
`301`	`302`	`m_client.get_io_service().dispatch(lib::bind(&client_impl::close_impl, this,close::status::policy_violation,"Pong timeout"));`
`302`	`303`	`}`
`303`	`304`
`@@ -312,7 +313,7 @@ namespace sio`
`312`	`313`	`m_con_state = con_opening;`
`313`	`314`	`m_reconn_made++;`
`314`	`315`	`this->reset_states();`
`315`		`- LOG("Reconnecting..."<<std::endl);`
	`316`	`+ LOG("Reconnecting..."<<endl);`
`316`	`317`	`if(m_reconnecting_listener) m_reconnecting_listener();`
`317`	`318`	`m_client.get_io_service().dispatch(lib::bind(&client_impl::connect_impl,this,m_base_url,m_query_string));`
`318`	`319`	`}`
`@@ -324,9 +325,9 @@ namespace sio`
`324`	`325`	`return min<unsigned>(static_cast<unsigned>(m_reconn_delay * pow(1.5,m_reconn_made)),m_reconn_delay_max);`
`325`	`326`	`}`
`326`	`327`
`327`		`- socket::ptr client_impl::get_socket_locked(std::string const& nsp)`
	`328`	`+ socket::ptr client_impl::get_socket_locked(string const& nsp)`
`328`	`329`	`{`
`329`		`- std::lock_guard<std::mutex> guard(m_socket_mutex);`
	`330`	`+ lock_guard<mutex> guard(m_socket_mutex);`
`330`	`331`	`auto it = m_sockets.find(nsp);`
`331`	`332`	`if(it != m_sockets.end())`
`332`	`333`	`{`
`@@ -340,9 +341,9 @@ namespace sio`
`340`	`341`
`341`	`342`	`void client_impl::sockets_invoke_void(void (sio::socket::*fn)(void))`
`342`	`343`	`{`
`343`		`- std::map<const std::string,socket::ptr> socks;`
	`344`	`+ map<const string,socket::ptr> socks;`
`344`	`345`	`{`
`345`		`- std::lock_guard<std::mutex> guard(m_socket_mutex);`
	`346`	`+ lock_guard<mutex> guard(m_socket_mutex);`
`346`	`347`	`socks.insert(m_sockets.begin(),m_sockets.end());`
`347`	`348`	`}`
`348`	`349`	`for (auto it = socks.begin(); it!=socks.end(); ++it) {`
`@@ -355,10 +356,10 @@ namespace sio`
`355`	`356`	`m_con.reset();`
`356`	`357`	`m_con_state = con_closed;`
`357`	`358`	`this->sockets_invoke_void(&sio::socket::on_disconnect);`
`358`		`- LOG("Connection failed." << std::endl);`
	`359`	`+ LOG("Connection failed." << endl);`
`359`	`360`	`if(m_reconn_made<m_reconn_attempts)`
`360`	`361`	`{`
`361`		`- LOG("Reconnect for attempt:"<<m_reconn_made<<std::endl);`
	`362`	`+ LOG("Reconnect for attempt:"<<m_reconn_made<<endl);`
`362`	`363`	`unsigned delay = this->next_delay();`
`363`	`364`	`if(m_reconnect_listener) m_reconnect_listener(m_reconn_made,delay);`
`364`	`365`	`m_reconn_timer.reset(new boost::asio::deadline_timer(m_client.get_io_service()));`
`@@ -374,23 +375,24 @@ namespace sio`
`374`	`375`
`375`	`376`	`void client_impl::on_open(connection_hdl con)`
`376`	`377`	`{`
`377`		`- LOG("Connected." << std::endl);`
	`378`	`+ LOG("Connected." << endl);`
`378`	`379`	`m_con_state = con_opened;`
`379`	`380`	`m_con = con;`
`380`	`381`	`m_reconn_made = 0;`
`381`	`382`	`this->sockets_invoke_void(&sio::socket::on_open);`
	`383`	`+ this->socket("");`
`382`	`384`	`if(m_open_listener)m_open_listener();`
`383`	`385`	`}`
`384`	`386`
`385`	`387`	`void client_impl::on_close(connection_hdl con)`
`386`	`388`	`{`
`387`		`- LOG("Client Disconnected." << std::endl);`
	`389`	`+ LOG("Client Disconnected." << endl);`
`388`	`390`	`m_con_state = con_closed;`
`389`	`391`	`lib::error_code ec;`
`390`	`392`	`close::status::value code = close::status::normal;`
`391`	`393`	`client_type::connection_ptr conn_ptr = m_client.get_con_from_hdl(con, ec);`
`392`	`394`	`if (ec) {`
`393`		`- LOG("OnClose get conn failed"<<ec<<std::endl);`
	`395`	`+ LOG("OnClose get conn failed"<<ec<<endl);`
`394`	`396`	`}`
`395`	`397`	`else`
`396`	`398`	`{`
`@@ -410,7 +412,7 @@ namespace sio`
`410`	`412`	`this->sockets_invoke_void(&sio::socket::on_disconnect);`
`411`	`413`	`if(m_reconn_made<m_reconn_attempts)`
`412`	`414`	`{`
`413`		`- LOG("Reconnect for attempt:"<<m_reconn_made<<std::endl);`
	`415`	`+ LOG("Reconnect for attempt:"<<m_reconn_made<<endl);`
`414`	`416`	`unsigned delay = this->next_delay();`
`415`	`417`	`if(m_reconnect_listener) m_reconnect_listener(m_reconn_made,delay);`
`416`	`418`	`m_reconn_timer.reset(new boost::asio::deadline_timer(m_client.get_io_service()));`
`@@ -447,15 +449,15 @@ namespace sio`
`447`	`449`	`const map<string,message::ptr>* values = &(obj_ptr->get_map());`
`448`	`450`	`auto it = values->find("sid");`
`449`	`451`	`if (it!= values->end()) {`
`450`		`- m_sid = std::static_pointer_cast<string_message>(it->second)->get_string();`
	`452`	`+ m_sid = static_pointer_cast<string_message>(it->second)->get_string();`
`451`	`453`	`}`
`452`	`454`	`else`
`453`	`455`	`{`
`454`	`456`	`goto failed;`
`455`	`457`	`}`
`456`	`458`	`it = values->find("pingInterval");`
`457`	`459`	`if (it!= values->end()&&it->second->get_flag() == message::flag_integer) {`
`458`		`- m_ping_interval = (unsigned)std::static_pointer_cast<int_message>(it->second)->get_int();`
	`460`	`+ m_ping_interval = (unsigned)static_pointer_cast<int_message>(it->second)->get_int();`
`459`	`461`	`}`
`460`	`462`	`else`
`461`	`463`	`{`
`@@ -464,7 +466,7 @@ namespace sio`
`464`	`466`	`it = values->find("pingTimeout");`
`465`	`467`
`466`	`468`	`if (it!=values->end()&&it->second->get_flag() == message::flag_integer) {`
`467`		`- m_ping_timeout = (unsigned) std::static_pointer_cast<int_message>(it->second)->get_int();`
	`469`	`+ m_ping_timeout = (unsigned) static_pointer_cast<int_message>(it->second)->get_int();`
`468`	`470`	`}`
`469`	`471`	`else`
`470`	`472`	`{`
`@@ -474,9 +476,9 @@ namespace sio`
`474`	`476`	`m_ping_timer.reset(new boost::asio::deadline_timer(m_client.get_io_service()));`
`475`	`477`	`boost::system::error_code ec;`
`476`	`478`	`m_ping_timer->expires_from_now(milliseconds(m_ping_interval), ec);`
`477`		`- if(ec)LOG("ec:"<<ec.message()<<std::endl);`
	`479`	`+ if(ec)LOG("ec:"<<ec.message()<<endl);`
`478`	`480`	`m_ping_timer->async_wait(lib::bind(&client_impl::ping,this,lib::placeholders::_1));`
`479`		`- LOG("On handshake,sid:"<<m_sid<<",ping interval:"<<m_ping_interval<<",ping timeout"<<m_ping_timeout<<std::endl);`
	`481`	`+ LOG("On handshake,sid:"<<m_sid<<",ping interval:"<<m_ping_interval<<",ping timeout"<<m_ping_timeout<<endl);`
`480`	`482`	`return;`
`481`	`483`	`}`
`482`	`484`	`failed:`
`@@ -521,13 +523,13 @@ namespace sio`
`521`	`523`
`522`	`524`	`void client_impl::on_encode(bool isBinary,shared_ptr<const string> const& payload)`
`523`	`525`	`{`
`524`		`- LOG("encoded payload length:"<<payload->length()<<std::endl);`
	`526`	`+ LOG("encoded payload length:"<<payload->length()<<endl);`
`525`	`527`	`m_client.get_io_service().dispatch(lib::bind(&client_impl::send_impl,this,payload,isBinary?frame::opcode::binary:frame::opcode::text));`
`526`	`528`	`}`
`527`	`529`
`528`	`530`	`void client_impl::clear_timers()`
`529`	`531`	`{`
`530`		`- LOG("clear timers"<<std::endl);`
	`532`	`+ LOG("clear timers"<<endl);`
`531`	`533`	`boost::system::error_code ec;`
`532`	`534`	`if(m_ping_timeout_timer)`
`533`	`535`	`{`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ namespace sio`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`// Client Functions - such as send, etc.`
`90`		`- void connect(const std::string& uri, const std::map<string, string>& queryString);`
	`90`	`+ void connect(const std::string& uri, const std::map<std::string, std::string>& queryString);`
`91`	`91`
`92`	`92`	`sio::socket::ptr const& socket(const std::string& nsp);`
`93`	`93`