
There is a sample base on Boost.Asio example --> chat. Most changes on chat_server.cpp chat_message.hpp: // // chat_message.hpp // ~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef CHAT_MESSAGE_HPP #define CHAT_MESSAGE_HPP #include <cstdio> #include <cstdlib> #include <cstring> class chat_message { public: enum { header_length = 4 }; enum { max_body_length = 512 }; chat_message() : body_length_(0) { } const char* data() const { return data_; } char* data() { return data_; } size_t length() const { return header_length + body_length_; } const char* body() const { return data_ + header_length; } char* body() { return data_ + header_length; } size_t body_length() const { return body_length_; } void body_length(size_t length) { body_length_ = length; if (body_length_ > max_body_length) body_length_ = max_body_length; } bool decode_header() { using namespace std; // For strncat and atoi. char header[header_length + 1] = ""; strncat(header, data_, header_length); body_length_ = atoi(header); if (body_length_ > max_body_length) { body_length_ = 0; return false; } return true; } void encode_header() { using namespace std; // For sprintf and memcpy. char header[header_length + 1] = ""; sprintf(header, "%4d", body_length_); memcpy(data_, header, header_length); } private: char data_[header_length + max_body_length]; size_t body_length_; }; #endif // CHAT_MESSAGE_HPP chat_client.cpp: // // chat_client.cpp // ~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #include <cstdlib> #include <deque> #include <iostream> #include <boost/bind.hpp> #include <boost/asio.hpp> #include <boost/thread.hpp> #include "chat_message.hpp" using boost::asio::ip::tcp; typedef std::deque<chat_message> chat_message_queue; class chat_client { public: chat_client(boost::asio::io_service& io_service, tcp::resolver::iterator endpoint_iterator) : io_service_(io_service), socket_(io_service) { tcp::endpoint endpoint = *endpoint_iterator; socket_.async_connect(endpoint, boost::bind(&chat_client::handle_connect, this, boost::asio::placeholders::error, ++endpoint_iterator)); } void write(const chat_message& msg) { io_service_.post(boost::bind(&chat_client::do_write, this, msg)); } void close() { io_service_.post(boost::bind(&chat_client::do_close, this)); } private: void handle_connect(const boost::system::error_code& error, tcp::resolver::iterator endpoint_iterator) { if (!error) { boost::asio::async_read(socket_, boost::asio::buffer(read_msg_.data(), chat_message::header_length), boost::bind(&chat_client::handle_read_header, this, boost::asio::placeholders::error)); } else if (endpoint_iterator != tcp::resolver::iterator()) { socket_.close(); tcp::endpoint endpoint = *endpoint_iterator; socket_.async_connect(endpoint, boost::bind(&chat_client::handle_connect, this, boost::asio::placeholders::error, ++endpoint_iterator)); } } void handle_read_header(const boost::system::error_code& error) { if (!error && read_msg_.decode_header()) { boost::asio::async_read(socket_, boost::asio::buffer(read_msg_.body(), read_msg_.body_length()), boost::bind(&chat_client::handle_read_body, this, boost::asio::placeholders::error)); } else { do_close(); } } void handle_read_body(const boost::system::error_code& error) { if (!error) { std::cout.write(read_msg_.body(), read_msg_.body_length()); std::cout << "\n"; boost::asio::async_read(socket_, boost::asio::buffer(read_msg_.data(), chat_message::header_length), boost::bind(&chat_client::handle_read_header, this, boost::asio::placeholders::error)); } else { do_close(); } } void do_write(chat_message msg) { bool write_in_progress = !write_msgs_.empty(); write_msgs_.push_back(msg); if (!write_in_progress) { boost::asio::async_write(socket_, boost::asio::buffer(write_msgs_.front().data(), write_msgs_.front().length()), boost::bind(&chat_client::handle_write, this, boost::asio::placeholders::error)); } } void handle_write(const boost::system::error_code& error) { if (!error) { write_msgs_.pop_front(); if (!write_msgs_.empty()) { boost::asio::async_write(socket_, boost::asio::buffer(write_msgs_.front().data(), write_msgs_.front().length()), boost::bind(&chat_client::handle_write, this, boost::asio::placeholders::error)); } } else { do_close(); } } void do_close() { socket_.close(); } private: boost::asio::io_service& io_service_; tcp::socket socket_; chat_message read_msg_; chat_message_queue write_msgs_; }; int main(int argc, char* argv[]) { try { if (argc != 3) { std::cerr << "Usage: chat_client <host> <port>\n"; return 1; } boost::asio::io_service io_service; tcp::resolver resolver(io_service); tcp::resolver::query query(argv[1], argv[2]); tcp::resolver::iterator iterator = resolver.resolve(query); chat_client c(io_service, iterator); boost::thread t(boost::bind(&boost::asio::io_service::run, &io_service)); char line[chat_message::max_body_length + 1]; while (std::cin.getline(line, chat_message::max_body_length + 1)) { using namespace std; // For strlen and memcpy. chat_message msg; msg.body_length(strlen(line)); memcpy(msg.body(), line, msg.body_length()); msg.encode_header(); c.write(msg); } c.close(); t.join(); } catch (std::exception& e) { std::cerr << "Exception: " << e.what() << "\n"; } return 0; } chat_server.cpp: // // chat_server.cpp // ~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #include <algorithm> #include <cstdlib> #include <deque> #include <iostream> #include <list> #include <set> #include <boost/bind.hpp> #include <boost/shared_ptr.hpp> #include <boost/enable_shared_from_this.hpp> #include <boost/asio.hpp> #include <boost/thread.hpp> #include "chat_message.hpp" using boost::asio::ip::tcp; //---------------------------------------------------------------------- typedef std::deque<chat_message> chat_message_queue; //---------------------------------------------------------------------- class chat_participant { public: virtual ~chat_participant() {} virtual void deliver(const chat_message& msg) = 0; virtual std::string identifier() = 0; virtual void close() = 0; }; typedef boost::shared_ptr<chat_participant> chat_participant_ptr; //---------------------------------------------------------------------- class releaser { public: virtual ~releaser() {}; virtual void session_release() = 0; }; class chat_room { public: void init(releaser *p) { parent_ = p; } void join(chat_participant_ptr participant) { std::cout << participant->identifier() << " join room " << identifier() << std::endl; participants_.insert(participant); std::for_each(recent_msgs_.begin(), recent_msgs_.end(), boost::bind(&chat_participant::deliver, participant, _1)); std::stringstream ss; ss << participant->identifier() << " join room "; chat_message msg; msg.body_length(ss.str().length()); memcpy(msg.body(), ss.str().c_str(), msg.body_length()); msg.encode_header(); deliver(msg); } void leave(chat_participant_ptr participant) { std::cout << participant->identifier() << " leave room " << identifier() << std::endl; participants_.erase(participant); std::stringstream ss; ss << participant->identifier() << " leave room "; chat_message msg; msg.body_length(ss.str().length()); memcpy(msg.body(), ss.str().c_str(), msg.body_length()); msg.encode_header(); deliver(msg); parent_->session_release(); } void deliver(const chat_message& msg) { recent_msgs_.push_back(msg); while (recent_msgs_.size() > max_recent_msgs) recent_msgs_.pop_front(); std::for_each(participants_.begin(), participants_.end(), boost::bind(&chat_participant::deliver, _1, boost::ref(msg))); } std::string identifier() { return identifier_; } const void identifier(const std::string &str) { identifier_ = str; } std::size_t live_count() const { return participants_.size(); } void close() { std::for_each(participants_.begin(), participants_.end(), boost::bind(&chat_participant::close, _1)); } private: std::set<chat_participant_ptr> participants_; enum { max_recent_msgs = 100 }; chat_message_queue recent_msgs_; std::string identifier_; releaser *parent_; }; //---------------------------------------------------------------------- class chat_session : public chat_participant, public boost::enable_shared_from_this<chat_session> { public: chat_session(boost::asio::io_service& io_service, chat_room& room) : socket_(io_service), io_service_(io_service), room_(room) { } tcp::socket& socket() { return socket_; } void start() { room_.join(shared_from_this()); boost::asio::async_read(socket_, boost::asio::buffer(read_msg_.data(), chat_message::header_length), boost::bind( &chat_session::handle_read_header, shared_from_this(), boost::asio::placeholders::error)); } void deliver(const chat_message& msg) { bool write_in_progress = !write_msgs_.empty(); write_msgs_.push_back(msg); if (!write_in_progress) { boost::asio::async_write(socket_, boost::asio::buffer(write_msgs_.front().data(), write_msgs_.front().length()), boost::bind(&chat_session::handle_write, shared_from_this(), boost::asio::placeholders::error)); } } virtual std::string identifier() { std::stringstream ss; ss << socket_.remote_endpoint().address().to_string() << ":" << socket_.remote_endpoint().port(); return ss.str(); } virtual void close() { io_service_.post(boost::bind(&chat_session::do_close, this)); } void handle_read_header(const boost::system::error_code& error) { if (!error && read_msg_.decode_header()) { boost::asio::async_read(socket_, boost::asio::buffer(read_msg_.body(), read_msg_.body_length()), boost::bind(&chat_session::handle_read_body, shared_from_this(), boost::asio::placeholders::error)); } else { room_.leave(shared_from_this()); } } void handle_read_body(const boost::system::error_code& error) { if (!error) { char buf[chat_message::max_body_length + 1]; memcpy(buf, read_msg_.body(), read_msg_.body_length()); buf[read_msg_.body_length()] ='\0'; std::stringstream ss; ss << identifier() << " say: " << buf; chat_message msg; msg.body_length(ss.str().length()); memcpy(msg.body(), ss.str().c_str(), msg.body_length()); msg.encode_header(); room_.deliver(msg); boost::asio::async_read(socket_, boost::asio::buffer(read_msg_.data(), chat_message::header_length), boost::bind(&chat_session::handle_read_header, shared_from_this(), boost::asio::placeholders::error)); } else { room_.leave(shared_from_this()); } } void handle_write(const boost::system::error_code& error) { if (!error) { write_msgs_.pop_front(); if (!write_msgs_.empty()) { boost::asio::async_write(socket_, boost::asio::buffer(write_msgs_.front().data(), write_msgs_.front().length()), boost::bind(&chat_session::handle_write, shared_from_this(), boost::asio::placeholders::error)); } } else { room_.leave(shared_from_this()); } } private: void do_close() { socket_.close(); } tcp::socket socket_; chat_room& room_; chat_message read_msg_; chat_message_queue write_msgs_; boost::asio::io_service &io_service_; }; typedef boost::shared_ptr<chat_session> chat_session_ptr; //---------------------------------------------------------------------- class chat_server : public releaser { public: chat_server(boost::asio::io_service& io_service, const tcp::endpoint& endpoint) : io_service_(io_service), acceptor_(io_service, endpoint), endpoint_(endpoint) { room_.init(this); std::stringstream ss; ss << endpoint.port(); room_.identifier(ss.str()); chat_session_ptr new_session(new chat_session(io_service_, room_)); acceptor_.async_accept(new_session->socket(), boost::bind(&chat_server::handle_accept, this, new_session, boost::asio::placeholders::error)); } void handle_accept(chat_session_ptr session, const boost::system::error_code& error) { if (!error) { session->start(); //if (room_.live_count() < 2) { chat_session_ptr new_session(new chat_session(io_service_, room_)); acceptor_.async_accept(new_session->socket(), boost::bind(&chat_server::handle_accept, this, new_session, boost::asio::placeholders::error)); //} //else { //acceptor_.close(); //} } } virtual void session_release() { /* open again */ /* * if (room_.live_count() < 2) { acceptor_.open(endpoint_.protocol()); acceptor_.set_option(boost::asio::socket_base::reuse_address(true)); acceptor_.bind(endpoint_); acceptor_.listen(); } */ } void close() { io_service_.post(boost::bind(&chat_server::do_close, this)); room_.close(); } private: void do_close() { acceptor_.close(); } boost::asio::io_service& io_service_; tcp::acceptor acceptor_; chat_room room_; tcp::endpoint endpoint_; }; typedef boost::shared_ptr<chat_server> chat_server_ptr; typedef std::list<chat_server_ptr> chat_server_list; //---------------------------------------------------------------------- int main(int argc, char* argv[]) { try { if (argc < 2) { std::cerr << "Usage: chat_server <port> [<port> ...]\n"; return 1; } boost::asio::io_service io_service; chat_server_list servers; for (int i = 1; i < argc; ++i) { using namespace std; // For atoi. tcp::endpoint endpoint(tcp::v4(), atoi(argv[i])); chat_server_ptr server(new chat_server(io_service, endpoint)); servers.push_back(server); } boost::thread io_thread(boost::bind(&boost::asio::io_service::run, &io_service)); std::string line; while(getline(std::cin, line)) { if (line == "exit") { chat_server_list::iterator it = servers.begin(); for ( ; it != servers.end(); ++it) (*it)->close(); break; } } io_thread.join(); } catch (std::exception& e) { std::cerr << "Exception: " << e.what() << "\n"; } return 0; } step 1: start server step 2: start client, connect to server step 3: on server, type "exit" result: server crashed "This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information." 2010/3/8 OvermindDL1 <overminddl1@gmail.com>:
On Sun, Mar 7, 2010 at 5:58 PM, l.jay Yuan <pass86@gmail.com> wrote:
in msvcrt.dll
But in the callstack at that point, what is your last code that is called, better to just past the callstack here, or even better, post a complete compilable example that demonstrates your problem.
Also, please do not top-post. _______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users