Still need to work out what to do with TLS and XML; need to add a state machine to the XMPP client.

glynos · glynos · commit fc8c1538eaa2 · 2010-10-18T22:28:36.000+02:00
diff --git a/boost/network/auth/sasl.hpp b/boost/network/auth/sasl.hpp
@@ -28,17 +28,17 @@ class basic_sasl {
     typedef typename string<Tag>::type string_type;
 
     // explicit basic_sasl(anonymous);
-    // 
+    //
     // explicit basic_sasl(plain,
     //                     const string_type &id, const string_type &password);
-    // 
+    //
     // explicit basic_sasl(digest_md5,
     //                     const string_type &challenge,const string_type &jid, const string_type &password);
 
 private:
 
     string_type auth_string_;
-    
+
 };
 } // namespace auth
 } // namespace network
diff --git a/boost/network/protocol/xmpp/client.hpp b/boost/network/protocol/xmpp/client.hpp
@@ -49,18 +49,24 @@ class basic_client : boost::noncopyable {
 
 private:
 
+    enum connection_state {
+        disconnected,
+        processing_stream_features,
+        processing_starttls
+    };
+
     typedef basic_client<Tag, version_major, version_minor, Handler> this_type;
     typedef typename detail::parser_backend<Tag>::type parser_type;
 
 public:
 
     typedef typename string<Tag>::type string_type;
-    
+
     typedef basic_message<Tag> message_type;
     typedef basic_presence<Tag> presence_type;
     typedef basic_iq<Tag> iq_type;
     typedef basic_error<Tag> error_type;
-    
+
     explicit basic_client(Handler &handler);
 
     ~basic_client();
@@ -100,7 +106,7 @@ class basic_client : boost::noncopyable {
 
     // tcp socket
     boost::asio::ip::tcp::socket socket_;
-    
+
     // tls
     // sasl
 
@@ -112,7 +118,7 @@ class basic_client : boost::noncopyable {
 
     // std::deque<std::string> stanza_queue_;
     std::string write_buffer_, read_buffer_;
-    
+
 };
 
 
@@ -124,7 +130,7 @@ template <
     >
 basic_client<Tag, version_major, version_minor, Handler>::basic_client(Handler &handler)
     : handler_(handler), socket_(io_service_), work_(io_service_) {
-    
+
 }
 
 
@@ -135,7 +141,7 @@ template <
     class Handler
     >
 basic_client<Tag, version_major, version_minor, Handler>::~basic_client() {
-    
+
 }
 
 template <
@@ -145,7 +151,7 @@ template <
     class Handler
     >
 void basic_client<Tag, version_major, version_minor, Handler>::set_lang(const string_type &lang) {
-    
+
 }
 
 
@@ -158,7 +164,7 @@ template <
 void basic_client<Tag, version_major, version_minor, Handler>::connect(const string_type &jid,
                                                                        const string_type &password) {
     using boost::asio::ip::tcp;
-    
+
     // get the JID domain
     // default port is 5222
     // open socket
@@ -254,7 +260,7 @@ void basic_client<Tag, version_major, version_minor, Handler>::handle_connect(
     boost::asio::ip::tcp::resolver::iterator iterator) {
     if (!ec) {
         std::ostringstream os;
-        os << 
+        os <<
             "<?xml version=\"1.0\"?>" <<
             "<stream:stream to=\"" << "127.0.0.1" << "\" " <<
             "version=\"" << version_major << "." << version_minor << "\" " <<
@@ -403,7 +409,7 @@ struct client : basic_client<tags::default_, 1, 0, Handler> {
 
     explicit client(Handler &handler)
         : basic_client<tags::default_, 1, 0, Handler>(handler) {
-        
+
     }
 
 };
diff --git a/boost/network/protocol/xmpp/error.hpp b/boost/network/protocol/xmpp/error.hpp
@@ -22,9 +22,9 @@ class basic_error
 public:
 
     basic_error() {
-        
+
     }
-    
+
 };
 
 
diff --git a/boost/network/protocol/xmpp/iq.hpp b/boost/network/protocol/xmpp/iq.hpp
@@ -29,13 +29,13 @@ class basic_iq
     typedef typename base_type::headers_container_type headers_container_type;
 
     basic_iq() {
-        static const char name[] = {'i', 'q'};
+        static const char name[] = {'i', 'q', 0};
         base_type::set_name(string_type(name, name + sizeof(name)));
     }
 
     basic_iq(const basic_iq &other)
         : basic_stanza<Tag>(other) {
-        
+
     }
 
     basic_iq &operator = (const basic_iq &other) {
@@ -45,14 +45,14 @@ class basic_iq
     }
 
     ~basic_iq() {
-        
+
     }
 
     void swap(basic_iq &other) {
         base_type::swap(other);
     }
-    
-}; 
+
+};
 
 
 typedef basic_iq<tags::default_> iq;
diff --git a/boost/network/protocol/xmpp/message.hpp b/boost/network/protocol/xmpp/message.hpp
@@ -29,13 +29,13 @@ class basic_message
     typedef typename base_type::headers_container_type headers_container_type;
 
     basic_message() {
-        static const char name[] = {'m', 'e', 's', 's', 'a', 'g', 'e'};
+        static const char name[] = {'m', 'e', 's', 's', 'a', 'g', 'e', 0};
         base_type::set_name(string_type(name, name + sizeof(name)));
     }
 
     basic_message(const basic_message &other)
         : basic_stanza<Tag>(other) {
-        
+
     }
 
     basic_message &operator = (const basic_message &other) {
@@ -45,33 +45,33 @@ class basic_message
     }
 
     ~basic_message() {
-        
+
     }
 
     void swap(basic_message &other) {
         base_type::swap(other);
     }
 
     void set_type(const string_type &type) {
-        static const char *type_ = "type";
+        static const char type_[] = {'t', 'y', 'p', 'e', 0};
         set_attribute(string_type(type_, type_ + std::strlen(type_)), type);
     }
 
     string_type type() const {
-        static const char *type_ = "type";
+        static const char type_[] = {'t', 'y', 'p', 'e', 0};
         return get_attribute(string_type(type_, type_ + std::strlen(type_)));
     }
 
     void set_id(const string_type &id) {
-        static const char *id_ = "id";
+        static const char id_[] = {'i', 'd', 0};
         set_attribute(string_type(id_, id_ + std::strlen(id_)), id);
     }
 
     string_type id() const {
-        static const char *id_ = "id";
+        static const char id_[] = {'i', 'd', 0};
         return get_attribute(string_type(id_, id_ + std::strlen(id_)));
     }
-    
+
 };
 
 
diff --git a/boost/network/protocol/xmpp/namespaces.hpp b/boost/network/protocol/xmpp/namespaces.hpp
@@ -21,7 +21,7 @@ template <
 inline
 typename string<Tag>::type client() {
     static const char client[] = {
-        'j', 'a', 'b', 'b', 'e', 'r', ':', 'c', 'l', 'i', 'e', 'n', 't'};
+        'j', 'a', 'b', 'b', 'e', 'r', ':', 'c', 'l', 'i', 'e', 'n', 't', 0};
     return typename string<Tag>::type(
         client, client + sizeof(client));
 }
@@ -32,7 +32,7 @@ template <
 inline
 typename string<Tag>::type server() {
     static const char server[] = {
-        'j', 'a', 'b', 'b', 'e', 'r', ':', 's', 'e', 'r', 'v', 'e', 'r'};
+        'j', 'a', 'b', 'b', 'e', 'r', ':', 's', 'e', 'r', 'v', 'e', 'r', 0};
     return typename string<Tag>::type(
         server, server + sizeof(server));
 }
@@ -44,7 +44,7 @@ inline
 typename string<Tag>::type component() {
     static const char component[] = {
         'j', 'a', 'b', 'b', 'e', 'r', ':', 'c', 'o', 'm', 'p', 'o',
-        'n', 'e', 'n', 't', ':', 'a', 'c', 'c', 'e', 'p', 't'};
+        'n', 'e', 'n', 't', ':', 'a', 'c', 'c', 'e', 'p', 't', 0};
     return typename string<Tag>::type(
         component, component + sizeof(component));
 }
@@ -57,7 +57,7 @@ typename string<Tag>::type streams() {
     static const char streams[] = {
         'h', 't', 't', 'p', ':', '/', '/', 'e', 't', 'h', 'e', 'r',
         'x', '.', 'j', 'a', 'b', 'b', 'e', 'r', '.', 'o', 'r', 'g',
-        '/', 's', 't', 'r', 'e', 'a', 'm', 's'};
+        '/', 's', 't', 'r', 'e', 'a', 'm', 's', 0};
     return typename string<Tag>::type(
         streams, streams + sizeof(streams));
 }
@@ -70,7 +70,7 @@ typename string<Tag>::type streams_ietf() {
     static const char streams_ietf[] = {
         'u', 'r', 'n', ':', 'i', 'e', 't', 'f', ':', 'p', 'a', 'r',
         'a', 'm', 's', ':', 'x', 'm', 'l', ':', 'n', 's', ':', 'x',
-        'm', 'p', 'p', '-', 's', 't', 'r', 'e', 'a', 'm', 's'};
+        'm', 'p', 'p', '-', 's', 't', 'r', 'e', 'a', 'm', 's', 0};
     return typename string<Tag>::type(
         streams_ietf, streams_ietf + sizeof(streams_ietf));
 }
@@ -83,7 +83,7 @@ typename string<Tag>::type tls() {
     static const char tls[] = {
         'u', 'r', 'n', ':', 'i', 'e', 't', 'f', ':', 'p', 'a', 'r',
         'a', 'm', 's', ':', 'x', 'm', 'l', ':', 'n', 's', ':', 'x',
-        'm', 'p', 'p', '-', 't', 'l', 's'};
+        'm', 'p', 'p', '-', 't', 'l', 's', 0};
     return typename string<Tag>::type(tls, tls + sizeof(tls));
 }
 
@@ -95,7 +95,7 @@ typename string<Tag>::type sasl() {
     static const char sasl[] = {
         'u', 'r', 'n', ':', 'i', 'e', 't', 'f', ':', 'p', 'a', 'r',
         'a', 'm', 's', ':', 'x', 'm', 'l', ':', 'n', 's', ':', 'x',
-        'm', 'p', 'p', '-', 's', 'a', 's', 'l'};
+        'm', 'p', 'p', '-', 's', 'a', 's', 'l', 0};
     return typename string<Tag>::type(sasl, sasl + sizeof(sasl));
 }
 } // namespace ns
diff --git a/boost/network/protocol/xmpp/presence.hpp b/boost/network/protocol/xmpp/presence.hpp
@@ -29,13 +29,13 @@ class basic_presence
     typedef typename base_type::headers_container_type headers_container_type;
 
     basic_presence() {
-        static const char name[] = {'p', 'r', 'e', 's', 'e', 'n', 'c', 'e'};
+        static const char name[] = {'p', 'r', 'e', 's', 'e', 'n', 'c', 'e', 0};
         base_type::set_name(string_type(name, name + sizeof(name)));
     }
 
     basic_presence(const basic_presence &other)
         : basic_stanza<Tag>(other) {
-        
+
     }
 
     basic_presence &operator = (const basic_presence &other) {
@@ -45,7 +45,7 @@ class basic_presence
     }
 
     ~basic_presence() {
-        
+
     }
 
     void swap(basic_presence &other) {
diff --git a/boost/network/protocol/xmpp/stanza.hpp b/boost/network/protocol/xmpp/stanza.hpp
@@ -22,13 +22,13 @@ class basic_stanza
     : public boost::network::basic_message<Tag> {
 
     typedef boost::network::basic_message<Tag> base_type;
-    
+
 public:
 
     typedef typename base_type::string_type string_type;
 
     explicit basic_stanza() {
-        
+
     }
 
     explicit basic_stanza(const string_type &name) {
@@ -59,7 +59,7 @@ class basic_stanza
 private:
 
     detail::basic_element<Tag> element_;
-    
+
 };
 
 
diff --git a/boost/network/tags.hpp b/boost/network/tags.hpp
@@ -45,7 +45,7 @@ namespace boost { namespace network { namespace tags {
                 name##_tags,                                                \
                 mpl::inherit<mpl::placeholders::_1, mpl::placeholders::_2>  \
             >::type name;                                                   \
-    template <> struct components<name> { typedef name##_tags type; };     
+    template <> struct components<name> { typedef name##_tags type; };
 
     BOOST_NETWORK_DEFINE_TAG(http_default_8bit_tcp_resolve);
     BOOST_NETWORK_DEFINE_TAG(http_default_8bit_udp_resolve);
diff --git a/boost/network/tls/gnutls.hpp b/boost/network/tls/gnutls.hpp
@@ -30,22 +30,22 @@ basic_gnutls {
 
     gnutls_session_t session_;
     gnutls_certificate_credentials_t credentials_;
-    
+
 };
 
 
 template <
     class Tag
     >
 basic_gnutls<Tag>::basic_gnutls() {
-    
+
 }
 
 template <
     class Tag
     >
 basic_gnutls<Tag>::~basic_gnutls() {
-    
+
 }
 } // namespace network
 } // namespace boost
diff --git a/boost/network/xml/element.hpp b/boost/network/xml/element.hpp
diff --git a/boost/network/xml/element_io.hpp b/boost/network/xml/element_io.hpp
diff --git a/boost/network/xml/parser_backends/expat_parser.hpp b/boost/network/xml/parser_backends/expat_parser.hpp
diff --git a/boost/network/xml/parser_backends/libxml2_parser.hpp b/boost/network/xml/parser_backends/libxml2_parser.hpp

Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,9 @@ class basic_error`
`22`	`22`	`public:`
`23`	`23`
`24`	`24`	`basic_error() {`
`25`		`-`
	`25`	`+`
`26`	`26`	`}`
`27`		`-`
	`27`	`+`
`28`	`28`	`};`
`29`	`29`
`30`	`30`
Original file line number	Diff line number	Diff line change
`@@ -29,13 +29,13 @@ class basic_iq`
`29`	`29`	`typedef typename base_type::headers_container_type headers_container_type;`
`30`	`30`
`31`	`31`	`basic_iq() {`
`32`		`- static const char name[] = {'i', 'q'};`
	`32`	`+ static const char name[] = {'i', 'q', 0};`
`33`	`33`	`base_type::set_name(string_type(name, name + sizeof(name)));`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`basic_iq(const basic_iq &other)`
`37`	`37`	`: basic_stanza<Tag>(other) {`
`38`		`-`
	`38`	`+`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`basic_iq &operator = (const basic_iq &other) {`
`@@ -45,14 +45,14 @@ class basic_iq`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`~basic_iq() {`
`48`		`-`
	`48`	`+`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`void swap(basic_iq &other) {`
`52`	`52`	`base_type::swap(other);`
`53`	`53`	`}`
`54`		`-`
`55`		`-};`
	`54`	`+`
	`55`	`+};`
`56`	`56`
`57`	`57`
`58`	`58`	`typedef basic_iq<tags::default_> iq;`
Original file line number	Diff line number	Diff line change
`@@ -29,13 +29,13 @@ class basic_message`
`29`	`29`	`typedef typename base_type::headers_container_type headers_container_type;`
`30`	`30`
`31`	`31`	`basic_message() {`
`32`		`- static const char name[] = {'m', 'e', 's', 's', 'a', 'g', 'e'};`
	`32`	`+ static const char name[] = {'m', 'e', 's', 's', 'a', 'g', 'e', 0};`
`33`	`33`	`base_type::set_name(string_type(name, name + sizeof(name)));`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`basic_message(const basic_message &other)`
`37`	`37`	`: basic_stanza<Tag>(other) {`
`38`		`-`
	`38`	`+`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`basic_message &operator = (const basic_message &other) {`
`@@ -45,33 +45,33 @@ class basic_message`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`~basic_message() {`
`48`		`-`
	`48`	`+`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`void swap(basic_message &other) {`
`52`	`52`	`base_type::swap(other);`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`void set_type(const string_type &type) {`
`56`		`- static const char *type_ = "type";`
	`56`	`+ static const char type_[] = {'t', 'y', 'p', 'e', 0};`
`57`	`57`	`set_attribute(string_type(type_, type_ + std::strlen(type_)), type);`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`string_type type() const {`
`61`		`- static const char *type_ = "type";`
	`61`	`+ static const char type_[] = {'t', 'y', 'p', 'e', 0};`
`62`	`62`	`return get_attribute(string_type(type_, type_ + std::strlen(type_)));`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`void set_id(const string_type &id) {`
`66`		`- static const char *id_ = "id";`
	`66`	`+ static const char id_[] = {'i', 'd', 0};`
`67`	`67`	`set_attribute(string_type(id_, id_ + std::strlen(id_)), id);`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`string_type id() const {`
`71`		`- static const char *id_ = "id";`
	`71`	`+ static const char id_[] = {'i', 'd', 0};`
`72`	`72`	`return get_attribute(string_type(id_, id_ + std::strlen(id_)));`
`73`	`73`	`}`
`74`		`-`
	`74`	`+`
`75`	`75`	`};`
`76`	`76`
`77`	`77`
Original file line number	Diff line number	Diff line change
`@@ -29,13 +29,13 @@ class basic_presence`
`29`	`29`	`typedef typename base_type::headers_container_type headers_container_type;`
`30`	`30`
`31`	`31`	`basic_presence() {`
`32`		`- static const char name[] = {'p', 'r', 'e', 's', 'e', 'n', 'c', 'e'};`
	`32`	`+ static const char name[] = {'p', 'r', 'e', 's', 'e', 'n', 'c', 'e', 0};`
`33`	`33`	`base_type::set_name(string_type(name, name + sizeof(name)));`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`basic_presence(const basic_presence &other)`
`37`	`37`	`: basic_stanza<Tag>(other) {`
`38`		`-`
	`38`	`+`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`basic_presence &operator = (const basic_presence &other) {`
`@@ -45,7 +45,7 @@ class basic_presence`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`~basic_presence() {`
`48`		`-`
	`48`	`+`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`void swap(basic_presence &other) {`
Original file line number	Diff line number	Diff line change
`@@ -30,22 +30,22 @@ basic_gnutls {`
`30`	`30`
`31`	`31`	`gnutls_session_t session_;`
`32`	`32`	`gnutls_certificate_credentials_t credentials_;`
`33`		`-`
	`33`	`+`
`34`	`34`	`};`
`35`	`35`
`36`	`36`
`37`	`37`	`template <`
`38`	`38`	`class Tag`
`39`	`39`	`>`
`40`	`40`	`basic_gnutls<Tag>::basic_gnutls() {`
`41`		`-`
	`41`	`+`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`template <`
`45`	`45`	`class Tag`
`46`	`46`	`>`
`47`	`47`	`basic_gnutls<Tag>::~basic_gnutls() {`
`48`		`-`
	`48`	`+`
`49`	`49`	`}`
`50`	`50`	`} // namespace network`
`51`	`51`	`} // namespace boost`