Misbahaving client causes program crash due to exception in send.c

[qt1]

A misbehaving client triggers an exception in send.c, probably because prematurely closing the server->client stream.

As a result the program terminates.

It should be possible to set a try-catch block that will prevent the server stopping .
I did not find a way in the docs.

Call Stack:
libpthread.so.0!__libc_send(int flags, size_t len, const void * buf, int fd) (/build/glibc-ZN95T4/glibc-2.31/sysdeps/unix/sysv/linux/send.c:28)
libpthread.so.0!__libc_send(int fd, const void * buf, size_t len, int flags) (/build/glibc-ZN95T4/glibc-2.31/sysdeps/unix/sysv/linux/send.c:23)
httplib::detail::SocketStream::write(char const*, unsigned long)::{lambda()#1}::operator()() const(const httplib::detail::SocketStream::<lambda()> * const __closure) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:3693)
httplib::detail::handle_EINTR<httplib::detail::SocketStream::write(char const*, unsigned long)::{lambda()#1}>(httplib::detail::SocketStream::write(char const*, unsigned long)::{lambda()#1})(httplib::detail::SocketStream::<lambda()> fn) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:1558)
httplib::detail::SocketStream::write(httplib::detail::SocketStream * const this, const char * ptr, size_t size) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:3693)
httplib::Stream::write(httplib::Stream * const this, const std::string & s) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:3612)
httplib::Server::write_response(httplib::Server * const this, httplib::Stream & strm, bool close_connection, const httplib::Request & req, httplib::Response & res) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:4061)
httplib::Server::process_request(httplib::Stream&, bool, bool&, std::function<void (httplib::Request&)> const&)(httplib::Server * const this, httplib::Stream & strm, bool close_connection, bool & connection_closed, const std::function<void(httplib::Request&)> & setup_request) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:4532)
httplib::Server::process_and_close_socket(int)::{lambda(httplib::Stream&, bool, bool&)#1}::operator()(httplib::Stream&, bool, bool&) const(const httplib::Server::<lambda(httplib::Stream&, bool, bool&)> * const __closure, httplib::Stream & strm, bool close_connection, bool & connection_closed) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:4542)
httplib::detail::process_server_socket<httplib::Server::process_and_close_socket(int)::{lambda(httplib::Stream&, bool, bool&)#1}>(int, unsigned long, long, long, long, long, httplib::Server::process_and_close_socket(int)::{lambda(httplib::Stream&, bool, bool&)#1})::{lambda(bool, bool)#1}::operator()(bool, bool) const(const httplib::detail::<lambda(bool, bool)> * const this, bool close_connection, bool connection_closed) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:1768)
httplib::detail::process_server_socket_core<httplib::detail::process_server_socket<httplib::Server::process_and_close_socket(int)::{lambda(httplib::Stream&, bool, bool&)#1}>(int, unsigned long, long, long, long, long, httplib::Server::process_and_close_socket(int)::{lambda(httplib::Stream&, bool, bool&)#1})::{lambda(bool, bool)#1}>(int, unsigned long, httplib::Server::process_and_close_socket(int)::{lambda(httplib::Stream&, bool, bool&)#1})(socket_t sock, size_t keep_alive_max_count, httplib::detail::<lambda(bool, bool)> callback) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:1750)
httplib::detail::process_server_socket<httplib::Server::process_and_close_socket(int)::{lambda(httplib::Stream&, bool, bool&)#1}>(int, unsigned long, long, long, long, long, httplib::Server::process_and_close_socket(int)::{lambda(httplib::Stream&, bool, bool&)#1})(socket_t sock, size_t keep_alive_max_count, time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec, time_t write_timeout_usec, httplib::Server::<lambda(httplib::Stream&, bool, bool&)> callback) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:1763)
httplib::Server::process_and_close_socket(httplib::Server * const this, socket_t sock) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:4538)
httplib::Server::listen_internal()::{lambda()#1}::operator()() const(const httplib::Server::<lambda()> * const __closure) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:4341)
std::_Function_handler<void (), httplib::Server::listen_internal()::{lambda()#1}>::_M_invoke(std::_Any_data const&)(const std::_Any_data & __functor) (/usr/include/c++/9/bits/std_function.h:300)
std::function<void ()>::operator()() const(const std::function<void()> * const this) (/usr/include/c++/9/bits/std_function.h:688)
httplib::ThreadPool::worker::operator()(httplib::ThreadPool::worker * const this) (/home/baruch/w/eneltec/tunnel-control-service/vendor/cpp-httplib/httplib.h:514)
std::__invoke_impl<void, httplib::ThreadPool::worker>(httplib::ThreadPool::worker && __f) (/usr/include/c++/9/bits/invoke.h:60)
std::__invokehttplib::ThreadPool::worker(httplib::ThreadPool::worker && __fn) (/usr/include/c++/9/bits/invoke.h:95)
std::thread::_Invoker<std::tuplehttplib::ThreadPool::worker >::_M_invoke<0ul>(std::thread::_Invoker<std::tuplehttplib::ThreadPool::worker > * const this) (/usr/include/c++/9/thread:244)

[yhirose]

@qt1, thanks for the feedback, but I'll close it for now until the smallest possible code snippet is given which proves that this problem is really caused by httplib.h (adding a unit test to test/test.cc is the best). Thanks for your consideration!

[qt1]

Well, probably not the smallest but small enough..

The test below runs 20 requests against a simple server.
The server has fast /f and slow /s responses.

The slow response adds 200 ms delay.

After two requests the client starts misbehaving = closing its connection before the response is ready.

At this mode the server fails after a few requests - as described above.

The output is logged with spdlog which adds timestamps.

There is a typical output:

starting server
client 1
[2020-10-02 19:44:04.879] [debug] === i = 0 ===
[2020-10-02 19:44:04.893] [debug] client write request to server
[2020-10-02 19:44:04.893] [debug] reading response
[2020-10-02 19:44:04.894] [debug] Get + sleep 200 ms
HTTP/1.1 200 OK
Connection: close
Content-Length: 17
Content-Type: text/plain

Hello World 200ms
[2020-10-02 19:44:05.095] [debug] client shutdown
[2020-10-02 19:44:05.095] [debug] close
[2020-10-02 19:44:05.095] [debug] done
[2020-10-02 19:44:05.095] [debug] === i = 1 ===
[2020-10-02 19:44:05.095] [debug] client write request to server
[2020-10-02 19:44:05.095] [debug] reading response
[2020-10-02 19:44:05.095] [debug] Get + sleep 200 ms
HTTP/1.1 200 OK
Connection: close
Content-Length: 17
Content-Type: text/plain

Hello World 200ms
[2020-10-02 19:44:05.296] [debug] client shutdown
[2020-10-02 19:44:05.296] [debug] close
[2020-10-02 19:44:05.296] [debug] done
[2020-10-02 19:44:05.296] [debug] === i = 2 ===
[2020-10-02 19:44:05.296] [debug] client write request to server
[2020-10-02 19:44:05.296] [debug] Get + sleep 200 ms
[2020-10-02 19:44:05.396] [debug] shutdown(fd, SHUT_RDWR)
[2020-10-02 19:44:05.396] [debug] reading response

[2020-10-02 19:44:05.396] [debug] client shutdown
[2020-10-02 19:44:05.396] [debug] close
[2020-10-02 19:44:05.396] [debug] done
[2020-10-02 19:44:05.396] [debug] === i = 3 ===
[2020-10-02 19:44:05.396] [debug] client write request to server
[2020-10-02 19:44:05.497] [debug] shutdown(fd, SHUT_RDWR)
[2020-10-02 19:44:05.497] [debug] reading response

[2020-10-02 19:44:05.497] [debug] client shutdown
[2020-10-02 19:44:05.497] [debug] close
[2020-10-02 19:44:05.497] [debug] done
[2020-10-02 19:44:05.497] [debug] === i = 4 ===
[2020-10-02 19:44:05.497] [debug] client write request to server

Error message (exception - see the first comment for more details on stack)

Unable to open 'send.c': Unable to read file '/build/glibc-ZN95T4/glibc-2.31/sysdeps/unix/sysv/linux/send.c' (Error: Unable to resolve non-existing file '/build/glibc-ZN95T4/glibc-2.31/sysdeps/unix/sysv/linux/send.c').

I'll add the source in next comment

[qt1]

test_client_abort.cpp

// Test what happens of a client aborts

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <chrono>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <thread>

#include "httplib.h"
#include "log.h"
using namespace httplib;
using namespace std;

int socket_connect(const char *host, in_port_t port) {
    struct hostent *hp;
    struct sockaddr_in addr;
    int on = 1, sock;

    if ((hp = gethostbyname(host)) == NULL) {
        herror("gethostbyname");
        exit(1);
    }
    bcopy(hp->h_addr, &addr.sin_addr, hp->h_length);
    addr.sin_port = htons(port);
    addr.sin_family = AF_INET;
    sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&on, sizeof(int));

    if (sock == -1) {
        perror("setsockopt");
        exit(1);
    }

    if (connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) {
        perror("connect");
        exit(1);
    }
    return sock;
}

#define BUFFER_SIZE 1024

#define HOST "localhost"
#define PORT 8080

void http_server() {
    Server srv;

    // fast - 0 delay get
    srv.Get("/f", [](const Request &req, Response &res) {
        log_d("Get");
        res.set_content("Hello World!", "text/plain");
    });

    // slow - 200 ms delay 
    srv.Get("/s", [](const Request &req, Response &res) {
        log_d("Get + sleep 200 ms");
        res.set_content("Hello World 200ms", "text/plain");
        this_thread::sleep_for(std::chrono::milliseconds(200));
    });

    srv.listen(HOST, PORT);
}

void test_client_abort() {
    spdlog::set_level(spdlog::level::trace);
    // set up a simple server
    printf("starting server\n");
    auto http_server_thread = thread(http_server);
    this_thread::sleep_for(std::chrono::milliseconds(100)); // let the server some time to open listener

    printf("client 1\n");
    int fd;
    char buffer[BUFFER_SIZE];
    int misbehave_start = 2;

    for (int i = 0; i < 20; i++) {
        log_d("=== i = {} ===", i);
        fd = socket_connect(HOST, PORT);
        const char *req = "GET /s HTTP/1.1\r\nConnection: close\r\n\r\n";
        log_d("client write request to server");
        write(fd, req, strlen(req));
        shutdown(fd, SHUT_WR);

        if (i >= misbehave_start) {
            // misbehave: close read stream prematurely after a short delay (shorter then the slow response)
            this_thread::sleep_for(std::chrono::milliseconds(100));
            log_d("shutdown(fd, SHUT_RDWR)");
            shutdown(fd, SHUT_RDWR);
        }

        log_d("reading response");
        bzero(buffer, BUFFER_SIZE);
        while (read(fd, buffer, BUFFER_SIZE - 1) > 0) {
            fprintf(stderr, "%s", buffer);
            bzero(buffer, BUFFER_SIZE);
        }

        printf("\n");

        log_d("client shutdown");
        shutdown(fd, SHUT_RDWR);
        log_d("close");
        close(fd);
        log_d("done");
    }
 
    http_server_thread.join();
    printf("http_server_thread.joined\n");
}

log.h

// logging facility
// 
// log function names follow esp convension

// see file://./../vendor/spdlog/example/example.cpp

#pragma once
#define IBN_LOG

#include "spdlog/cfg/env.h" // for loading levels from the environment variable
#include "spdlog/spdlog.h"

#include "spdlog/sinks/basic_file_sink.h"
#include "spdlog/sinks/stdout_color_sinks.h"


template<typename FormatString, typename... Args>
inline void log_t(const FormatString &fmt, const Args &... args)
{
    spdlog::trace(fmt, args...);
}

template<typename FormatString, typename... Args>
inline void log_d(const FormatString &fmt, const Args &... args)
{
    spdlog::debug(fmt, args...);
}

template<typename FormatString, typename... Args>
inline void log_i(const FormatString &fmt, const Args &... args)
{
    spdlog::info(fmt, args...);
}

template<typename FormatString, typename... Args>
inline void log_w(const FormatString &fmt, const Args &... args)
{
    spdlog::warn(fmt, args...);
}

template<typename FormatString, typename... Args>
inline void log_e(const FormatString &fmt, const Args &... args)
{
    spdlog::error(fmt, args...);
}

template<typename FormatString, typename... Args>
inline void log_c(const FormatString &fmt, const Args &... args)
{
    spdlog::critical(fmt, args...);
}


template<typename T>
inline void log_t(const T &msg)
{
    spdlog::trace(msg);
}

template<typename T>
inline void log_d(const T &msg)
{
    spdlog::debug(msg);
}

template<typename T>
inline void log_i(const T &msg)
{
    spdlog::info(msg);
}

template<typename T>
inline void log_w(const T &msg)
{
    spdlog::warn(msg);
}

template<typename T>
inline void log_e(const T &msg)
{
    spdlog::error(msg);
}

template<typename T>
inline void log_c(const T &msg)
{
    spdlog::critical(msg);
}


// fmt is also usefull for exceptions..

template<typename FormatString, typename... Args>
inline auto fmt_runtime_error(const FormatString &fmt, const Args &... args)
{
    return runtime_error(fmt::format(fmt, args...));
}

template<typename FormatString, typename... Args>
inline auto fmt_range_error(const FormatString &fmt, const Args &... args)
{
    return range_error(fmt::format(fmt, args...));
}

[yhirose]

@qt1, thanks for the detailed information. I'll try to reproduce it on my Mac when I have time.

[yhirose]

@qt1, I tried to run the code, but I couldn't build it because it requires other dependency like spdlog. Could you make just a one file which can reproduce it on posix environment like linux or macOS? Thanks!

[qt1]

Here is a version that does not depend on spdlog - no time printing and a bit uglier but failes the same on my Ubuntu 20.04 ..

// Test what happens of a client aborts

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <chrono>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <thread>

//#include "log.h"

#include "httplib.h"

using namespace httplib;
using namespace std;

#ifndef IBN_LOG
void log_d(string s) { printf("%s\n",s.c_str()); }
void log_d(string s, int i) { printf("%s %d\n",s.c_str(), i); }
void log_d(string s, string s2) { printf("%s %s\n",s.c_str(), s2.c_str()); }
void log_e(string s) { printf("Error: %s\n",s.c_str()); }
void log_e(string s, int i) { printf("Error: %s %d\n",s.c_str(), i); }
void log_e(string s, string s2) { printf("Error: %s %s\n",s.c_str(), s2.c_str()); }
#endif

int socket_connect(const char *host, in_port_t port) {
    struct hostent *hp;
    struct sockaddr_in addr;
    int on = 1, sock;

    if ((hp = gethostbyname(host)) == NULL) {
        herror("gethostbyname");
        exit(1);
    }
    bcopy(hp->h_addr, &addr.sin_addr, hp->h_length);
    addr.sin_port = htons(port);
    addr.sin_family = AF_INET;
    sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&on, sizeof(int));

    if (sock == -1) {
        perror("setsockopt");
        exit(1);
    }

    if (connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) {
        perror("connect");
        exit(1);
    }
    return sock;
}

#define BUFFER_SIZE 1024

#define HOST "localhost"
#define PORT 8080

void http_server() {
    Server srv;

    // fast - 0 delay get
    srv.Get("/f", [](const Request &req, Response &res) {
        log_d("Get");
        res.set_content("Hello World!", "text/plain");
    });

    // slow - 200 ms delay 
    srv.Get("/s", [](const Request &req, Response &res) {
        log_d("Get + sleep 200 ms");
        res.set_content("Hello World 200ms", "text/plain");
        this_thread::sleep_for(std::chrono::milliseconds(200));
    });

    srv.listen(HOST, PORT);
}

void test_client_abort() {
    //spdlog::set_level(spdlog::level::trace);
    // set up a simple server
    printf("starting server\n");
    auto http_server_thread = thread(http_server);
    this_thread::sleep_for(std::chrono::milliseconds(100)); // let the server some time to open listener

    printf("client 1\n");
    int fd;
    char buffer[BUFFER_SIZE];
    int misbehave_start = 2;

    for (int i = 0; i < 20; i++) {
        log_d("=== i = {} ===", i);
        fd = socket_connect(HOST, PORT);
        const char *req = "GET /s HTTP/1.1\r\nConnection: close\r\n\r\n";
        log_d("client write request to server");
        write(fd, req, strlen(req));
        shutdown(fd, SHUT_WR);

        if (i >= misbehave_start) {
            // misbehave: close read stream prematurely after a short delay (shorter then the slow response)
            this_thread::sleep_for(std::chrono::milliseconds(100));
            log_d("shutdown(fd, SHUT_RDWR)");
            shutdown(fd, SHUT_RDWR);
        }

        log_d("reading response");
        bzero(buffer, BUFFER_SIZE);
        while (read(fd, buffer, BUFFER_SIZE - 1) > 0) {
            fprintf(stderr, "%s", buffer);
            bzero(buffer, BUFFER_SIZE);
        }

        printf("\n");

        log_d("client shutdown");
        shutdown(fd, SHUT_RDWR);
        log_d("close");
        close(fd);
        log_d("done");
    }
 
    http_server_thread.join();
    printf("http_server_thread.joined\n");
}

[yhirose]

@qt1, it seems like your socket_connect has a problem? (If detail::create_client_socket is used, no problem happens.)

// Test what happens of a client aborts

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <chrono>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <thread>

//#include "log.h"

#include "httplib.h"

using namespace httplib;
using namespace std;

#ifndef IBN_LOG
void log_d(string s) { printf("%s\n",s.c_str()); }
void log_d(string s, int i) { printf("%s %d\n",s.c_str(), i); }
void log_d(string s, string s2) { printf("%s %s\n",s.c_str(), s2.c_str()); }
void log_e(string s) { printf("Error: %s\n",s.c_str()); }
void log_e(string s, int i) { printf("Error: %s %d\n",s.c_str(), i); }
void log_e(string s, string s2) { printf("Error: %s %s\n",s.c_str(), s2.c_str()); }
#endif

int socket_connect(const char *host, in_port_t port) {
    struct hostent *hp;
    struct sockaddr_in addr;
    int on = 1, sock;

    if ((hp = gethostbyname(host)) == NULL) {
        herror("gethostbyname");
        exit(1);
    }
    bcopy(hp->h_addr, &addr.sin_addr, hp->h_length);
    addr.sin_port = htons(port);
    addr.sin_family = AF_INET;
    sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&on, sizeof(int));

    if (sock == -1) {
        perror("setsockopt");
        exit(1);
    }

    if (connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) {
        perror("connect");
        exit(1);
    }
    return sock;
}

#define BUFFER_SIZE 1024

#define HOST "localhost"
#define PORT 8080

void http_server() {
    Server srv;

    // fast - 0 delay get
    srv.Get("/f", [](const Request &req, Response &res) {
        log_d("Get");
        res.set_content("Hello World!", "text/plain");
    });

    // slow - 200 ms delay 
    srv.Get("/s", [](const Request &req, Response &res) {
        log_d("Get + sleep 200 ms");
        res.set_content("Hello World 200ms", "text/plain");
        this_thread::sleep_for(std::chrono::milliseconds(200));
    });

    srv.listen(HOST, PORT);
}

void test_client_abort() {
    //spdlog::set_level(spdlog::level::trace);
    // set up a simple server
    printf("starting server\n");
    auto http_server_thread = thread(http_server);
    this_thread::sleep_for(std::chrono::milliseconds(100)); // let the server some time to open listener

    printf("client 1\n");
    int fd;
    char buffer[BUFFER_SIZE];
    int misbehave_start = 2;

    for (int i = 0; i < 20; i++) {
        log_d("=== i = {} ===", i);
#if 1
        Error error = Error::Success;
        fd = detail::create_client_socket(HOST, PORT, false, nullptr, 5, 0, std::string(), error);
#else
        fd = socket_connect(HOST, PORT);
#endif

        const char *req = "GET /s HTTP/1.1\r\nConnection: close\r\n\r\n";
        log_d("client write request to server");
        write(fd, req, strlen(req));
        shutdown(fd, SHUT_WR);

        if (i >= misbehave_start) {
            // misbehave: close read stream prematurely after a short delay (shorter then the slow response)
            this_thread::sleep_for(std::chrono::milliseconds(100));
            log_d("shutdown(fd, SHUT_RDWR)");
            shutdown(fd, SHUT_RDWR);
        }

        log_d("reading response");
        bzero(buffer, BUFFER_SIZE);
        while (read(fd, buffer, BUFFER_SIZE - 1) > 0) {
            fprintf(stderr, "%s", buffer);
            bzero(buffer, BUFFER_SIZE);
        }

        printf("\n");

        log_d("client shutdown");
        shutdown(fd, SHUT_RDWR);
        log_d("close");
        close(fd);
        log_d("done");
    }
 
    http_server_thread.join();
    printf("http_server_thread.joined\n");
}

int main(void) {
  test_client_abort();
}

[qt1]

This seems like a change is in the client.
The client is just some random code to replicate the problem.

The actual (server) problem happens with a browser (firefox) client that may physically be disconnected or the user can click buttons at random and get the server to crash.

[yhirose]

@qt1, I probably don't fully understand what you are reporting... The code that I presented is exactly same as your sample code except how to create a socket. Anything else like prematurely closing the socket is same as it is.

Here is the actual result with your original test sample running on my macOS:

> ~/cpp-httplib$ ./a.out 
starting server
client 1
=== i = {} === 0
connect: Connection refused

I didn't even get the crash, but got connect: Connection refused message and it exited with exit(1).
Am I missing something that your environment has? I tried to debug it, but I can't reproduce the crash and cannot go any further... Thanks for your help.

[qt1]

OK, Sorry for the misunderstanding..

The problem:
I have a simple cpp-httplib C++ REST server that responds to some button clicks in a web application.
Usually all is working very well (and I am really happy with your API)..

However, while debugging, sometimes the server stops in an exception - as reported in this issue. This sometime happens when clicking too many buttons at once on the JS code in the browser..

The little client example is meant just to demo a misbehaving client that will trigger the problem in the server.

I am not sure why you get 'connection refused'
Obviously the code has compiled and started running.
My first guess is some kind of security/firewall setting, or maybe some other program listener on port 8080.

In any case, at the moment is seems like that exception stops the debugger but in the same situation the code does not hang when not in the debugger. So this becomes lower priority for me.

Thanks very much for the response.

[yhirose]

@qt1, thanks for the info.

My first guess is some kind of security/firewall setting, or maybe some other program listener on port 8080.
When detail::create_client_socket is used, such a connection problem doesn't happen. On the exact same environment, the connection error happens with socket_connect function.

Glad to head that this isn't a big issue any more. Since there is no way for me to reproduce it, I'll close it for now. When you get more detailed information that could be helpful to reproduce it, please me know. Thanks!