std::string copy constructor seg fault

this happens when constructing a structure, my code: http://wklej.org/hash/c42680a7f9d/txt/ 开发者_如何学JAVAat this line: http://wklej.org/hash/5fefcecc371/txt/ backtrace: http://wklej.org/id/451070/txt/ any help is apperciated Sorry, i fail to copy the code here so i post it at any other site ;(

---

Use a debugger and get a stack trace.

The problem is almost certainly passing a bad C string into the std::string constructor. Perhaps the pointer is invalid or the C string does not terminate and the constructor reads off into protected memory.

But without more information I can't tell what the bug is. The debugger should point it out immediately.

Also, your Socket holds a pointer but only defines a constructor and destructor. You also need a copy constructor and an assignment operator. If those two operations aren't supposed to happen then define them as private with no implementation.

Also, I see from your backtrace that this is an old version of GCC. It's possible that this version does not have the fixes that make std::string safe to use in multi-threaded programs. I don't know when it was fixed but some older versions of the libstdc++ library didn't lock the reference counts on the string and could crash when different threads would free the string memory while also writing to it.

---

I've placed your code here in order to be able to edit it:

#ifdef _WIN32
    #define _WIN32_WINNT 0x0501
#endif

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/noncopyable.hpp>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <sstream>
#include <string>

#ifdef assert
    #undef assert
#endif

#define assert(x)\
    if (!x) { \
        std::clog << "[Error - __FUNCTION__] Asseration to: " << #x << " failed. line: " << __LINE__ << ", file: " << __FILE__ << "." << std::endl;\
        std::exit(100);\
    }

template<typename _Tp>
inline std::string toString(_Tp __p)
{
    std::stringstream ss;
    ss << __p;
    std::string ret;
    ss >> ret;
    return ret;
}

struct Proxy;

typedef std::vector<Proxy*> ProxyVec;

struct Proxy
{
    std::string name;
    uint32_t port;
};

ProxyVec loadProxies(const std::string& fileName)
{
    std::FILE *f = fopen(fileName.c_str(), "r");
    if (!f) {
        std::clog << "[Error - loadProxies] Cannot open: " << fileName << "." << std::endl;
        delete f;
        f = NULL;
        return ProxyVec();
    }

    char buffer[1024];
    ProxyVec ret;
    int32_t __n = 0;
    while (fgets(buffer, sizeof(buffer), f)) {
        ++__n;
        std::string str(buffer);
        if (str.find("\n") != std::string::npos)
            str = str.substr(0, str.length()-1);

        if (str.find("\r") != std::string::npos)
            str = str.substr(0, str.length()-1);

        size_t sep = str.rfind(":");
        if (sep == std::string::npos) {
            std::clog << "[Error - loadProxies] Cannot load proxy #" << __n << "." << std::endl;
            continue;
        }

        std::string hostname = str.substr(0, sep);
        uint32_t port = static_cast<uint32_t>(std::atoi(str.substr(sep+1, str.length()-sep).c_str()));
        std::clog << "Loading proxy: " << hostname << ":" << port << "." << std::endl;
        Proxy proxy;
        proxy.name = hostname;
        proxy.port = port;
        ret.push_back(&proxy);
    }
    std::clog << "Loaded: " << __n << " proxies." << std::endl;
    return ret;
}

class Socket
{
    public:
        Socket(boost::asio::io_service& service, const std::string& host, 
            const std::string& port, const std::string& targetHost, const std::string& targetPort);
        ~Socket();

        void write(const std::string& message);
        std::string receivedData() const;
        bool connected() const;
        void receive();
        void handle();

    private:
        struct SocketData
        {
            SocketData(boost::asio::io_service& service, const std::string& _host, const std::string& _port,
                const std::string& _targetHost, const std::string& _targetPort):
                socket(service),
                write(service),
                read(service),
                resolver(service),
                buffers(),
                host(_host),
                port(_port),
                targetHost(_targetHost),
                targetPort(_targetPort),
                connected(false)
            {
            }
            boost::asio::ip::tcp::socket socket;
            boost::asio::io_service::strand write, read;
            boost::asio::ip::tcp::resolver resolver;
            boost::array<char, 1024> buffers;
            std::string host, port;
            std::string targetHost, targetPort;
            bool connected;
        };
            // FIXME: Use shared_ptr instead.
        SocketData* d;

    protected:
        //handle resolve func
        void handle_resolve(const boost::system::error_code&,
            boost::asio::ip::tcp::resolver::iterator);

        //handle connection func
        void handle_connect(const boost::system::error_code&,
            boost::asio::ip::tcp::resolver::iterator);

        //handle write func
        void handle_write(const boost::system::error_code&, size_t);

        //handle read func
        void handle_read(const boost::system::error_code&, size_t);

    private:
        void connectionThread();
};

Socket::Socket(boost::asio::io_service& service, const std::string& host, const std::string& port,
    const std::string& targetHost, const std::string& targetPort)
    : d(new SocketData(service, host, port, targetHost, targetPort))
{
    boost::thread thread(boost::bind(&Socket::connectionThread, this));
    // FIXME: This function is blocking. The constructur will never exit.
    //        Use thread_group.join_all() as last line in main() instead.
    thread.join();
}

Socket::~Socket()
{
    d->socket.close();
    delete d;
    d = NULL;
}

void Socket::connectionThread()
{
    if (!d)
        return;

    if (d->connected)
        return;

    boost::asio::ip::tcp::resolver::query query(d->host, d->port);
    d->resolver.async_resolve(query,
        boost::bind(&Socket::handle_resolve, this,
            boost::asio::placeholders::error,
                boost::asio::placeholders::iterator));
}

void Socket::handle_resolve(const boost::system::error_code& e,
    boost::asio::ip::tcp::resolver::iterator ep_iter)
{
    if (!e) {
        boost::asio::ip::tcp::endpoint iter = *ep_iter;
        d->socket.async_connect(iter,
            boost::bind(&Socket::handle_connect, this,
                boost::asio::placeholders::error, ++ep_iter));
    } else {
        std::clog << "[Error - Socket::handle_resolve] " << e.message() << "." << std::endl;
    }
}

void Socket::handle_connect(const boost::system::error_code& e,
    boost::asio::ip::tcp::resolver::iterator ep_iter)
{
    if (!e) {
        std::cout << "[Notice - Socket::handle_connect] Connected to host." << std::endl;
        d->connected = true;
        write("CONNECT " + d->targetHost + ":" + d->targetPort + " HTTP/1.1\r\n\r\n");
        receive();
    } else if (ep_iter != boost::asio::ip::tcp::resolver::iterator()) {
        d->socket.close();
        boost::asio::ip::tcp::endpoint ep = *ep_iter;
        d->socket.async_connect(ep,
            boost::bind(&Socket::handle_connect, this,
                boost::asio::placeholders::error, ++ep_iter));
    } else {
        std::clog << "[Error - Server::handle_connect] " << e.message() << "." << std::endl;
    }
}

void Socket::handle_write(const boost::system::error_code& e,
    size_t bytes)
{
    assert(!e || bytes < 0);
}

void Socket::handle_read(const boost::system::error_code& e,
    size_t bytes)
{
    assert(!e || bytes < 0);
    std::cout << receivedData() << std::endl;
    receive();
}

void Socket::write(const std::string& message)
{
    boost::asio::async_write(d->socket, boost::asio::buffer(message),
        d->write.wrap(
            boost::bind(&Socket::handle_write, this,
                boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred)));
}

std::string Socket::receivedData() const
{
    return std::string(d->buffers.data());
}

void Socket::receive()
{
    d->socket.async_read_some(boost::asio::buffer(d->buffers),
        d->read.wrap(
            boost::bind(&Socket::handle_read, this,
                boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred)));
}

void Socket::handle()
{
    assert(!d->targetHost.empty());
    assert(!d->targetPort.empty());

    std::string str(d->buffers.data());
    std::clog << "Received: " << str << "." << std::endl;
    if (str.substr(0, 4) == "PING")
        write("PO" + str.substr(2) + "\r\n");
    else if (str.find("MODE") != std::string::npos)
        write("JOIN #OTland\r\n");
    else if (str.find("JOIN") != std::string::npos)
        write("PRIVMSG #OTland :Hello\r\n");
}

bool Socket::connected() const
{
    return d->connected;
}

void handler(const std::string& fileName, const std::string& host, const std::string& port, uint32_t threads);

int main(int argc, char **argv)
{
    if (argc < 5) {
        std::clog << "[Error - main] Usage: " << argv[0] << " <proxy_file> <host> <port> <threads>" << std::endl;
        return 1;
    }

    std::string file(argv[1]);
    std::string host(argv[2]);
    std::string port(argv[3]);
    uint32_t threads = static_cast<uint32_t>(std::atoi(argv[4]));
    if (!threads)
        threads = 1;

    for (uint32_t __i = 0; __i < threads; ++__i)
            // FIXME: Use the thread.join() there.
        handler(file, host, port, threads);
}

typedef std::vector<Socket*> SocketVec;

void handler(const std::string& fileName, const std::string& host,
    const std::string& port, uint32_t threads)
{
    assert(!fileName.empty());
    assert(!host.empty());
    assert(!port.empty());

    ProxyVec proxies = loadProxies(fileName);
    assert(proxies.size());

    SocketVec sockets;
    for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
        boost::asio::io_service io;
        Socket socket(io, (*it)->name, toString((*it)->port), host, port);
            // FIXME: socket is a local variable and it's address is invalid outside
            //        this loop -> memory leak -> seg-fault.
        sockets.push_back(&socket);
    }

    for (SocketVec::const_iterator it = sockets.begin(); it != sockets.end(); ++it) {
        if (!(*it)->connected())
            continue;

        (*it)->handle();
    }
    // FIXME: I'm not sure if I understand this architecture. A new thread is
    //        started with this function as handler ? Who waits until this new created
    //        thread is finished ? Where is the join() ?
    (void) new boost::thread(boost::bind(handler, fileName, host, port, threads));
}

---

I don't think this is your only problem, but in this snippet in handler, you're creating your Socket objects on the stack. Each Socket object that you create will be destroyed at the end of the for loop. This means that the objects in the sockets vector are invalid objects. Doing this may also corrupt the memory heap enough to produce the error that you're seeing.

SocketVec sockets;
for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
    boost::asio::io_service io;
    Socket socket(io, (*it)->name, toString((*it)->port), host, port);
    sockets.push_back(&socket);
}

Change this to:

SocketVec sockets;
for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
    boost::asio::io_service io;
    Socket* socket = new Socket(io, (*it)->name, toString((*it)->port), host, port);
    sockets.push_back(socket);
}

---

This answer was originally a comment to Dan's answer, but after looking at your code I felt compelled to give a full answer. You really need to take a closer look at the Boost.Asio examples and understand how they work. Pay special attention to the asynchronous examples, it doesn't look like you've grasped the concepts of object lifetime and how the handlers work. Particularly, you should master single threaded programs before jumping into multiple threads. When you've conquered that, you should use a thread pool invoking io_service::run instead of an io_service per thread. It will ultimately make your program's logic easier to understand.

You also should look into valgrind, there's a slew of errors in your code like this one:

==19853== Invalid read of size 4
==19853==    at 0x10000D0E4: handler(std::string const&, std::string const&, std::string const&, unsigned int) (in ./a.out)
==19853==    by 0x10000D5E6: main (in ./a.out)
==19853==  Address 0x7fff5fbff398 is not stack'd, malloc'd or (recently) free'd