From 06e782f2abc43707937497dbf6498da51756a047 Mon Sep 17 00:00:00 2001 From: Eugene Ostroukhov Date: Wed, 14 Sep 2016 10:15:38 -0700 Subject: [PATCH] inspector: zero out structure members Ctor has to be added as memset to 0 is no longer an option, since the structure now has std::vector member. Attempt at fixing nodejs/node#8155 (so far I was not able to repro it) PR-URL: https://github.com/nodejs/node/pull/8536 Reviewed-By: bnoordhuis - Ben Noordhuis --- src/inspector_agent.cc | 37 +++++++------ src/inspector_socket.cc | 80 ++++++++++++++++------------ src/inspector_socket.h | 46 ++++++++++------ test/cctest/test_inspector_socket.cc | 18 ++++--- 4 files changed, 104 insertions(+), 77 deletions(-) diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc index 9c1dc6b8995c8e..60844d20eb8bfc 100644 --- a/src/inspector_agent.cc +++ b/src/inspector_agent.cc @@ -32,6 +32,7 @@ #endif namespace node { +namespace inspector { namespace { const char TAG_CONNECT[] = "#connect"; @@ -51,7 +52,7 @@ void PrintDebuggerReadyMessage(int port) { fflush(stderr); } -bool AcceptsConnection(inspector_socket_t* socket, const std::string& path) { +bool AcceptsConnection(InspectorSocket* socket, const std::string& path) { return StringEqualNoCaseN(path.c_str(), DEVTOOLS_PATH, sizeof(DEVTOOLS_PATH) - 1); } @@ -62,11 +63,11 @@ void Escape(std::string* string) { } } -void DisposeInspector(inspector_socket_t* socket, int status) { +void DisposeInspector(InspectorSocket* socket, int status) { delete socket; } -void DisconnectAndDisposeIO(inspector_socket_t* socket) { +void DisconnectAndDisposeIO(InspectorSocket* socket) { if (socket) { inspector_close(socket, DisposeInspector); } @@ -77,7 +78,7 @@ void OnBufferAlloc(uv_handle_t* handle, size_t len, uv_buf_t* buf) { buf->len = len; } -void SendHttpResponse(inspector_socket_t* socket, const char* response, +void SendHttpResponse(InspectorSocket* socket, const char* response, size_t len) { const char HEADERS[] = "HTTP/1.0 200 OK\r\n" "Content-Type: application/json; charset=UTF-8\r\n" @@ -90,7 +91,7 @@ void SendHttpResponse(inspector_socket_t* socket, const char* response, inspector_write(socket, response, len); } -void SendVersionResponse(inspector_socket_t* socket) { +void SendVersionResponse(InspectorSocket* socket) { const char VERSION_RESPONSE_TEMPLATE[] = "[ {" " \"Browser\": \"node.js/%s\"," @@ -117,7 +118,7 @@ std::string GetProcessTitle() { } } -void SendTargentsListResponse(inspector_socket_t* socket, +void SendTargentsListResponse(InspectorSocket* socket, const std::string& script_name_, const std::string& script_path_, int port) { @@ -169,7 +170,7 @@ const char* match_path_segment(const char* path, const char* expected) { return nullptr; } -bool RespondToGet(inspector_socket_t* socket, const std::string& script_name_, +bool RespondToGet(InspectorSocket* socket, const std::string& script_name_, const std::string& script_path_, const std::string& path, int port) { const char* command = match_path_segment(path.c_str(), "/json"); @@ -192,8 +193,6 @@ bool RespondToGet(inspector_socket_t* socket, const std::string& script_name_, } // namespace -namespace inspector { - class V8NodeInspector; @@ -220,7 +219,7 @@ class AgentImpl { static void ThreadCbIO(void* agent); static void OnSocketConnectionIO(uv_stream_t* server, int status); - static bool OnInspectorHandshakeIO(inspector_socket_t* socket, + static bool OnInspectorHandshakeIO(InspectorSocket* socket, enum inspector_handshake_event state, const std::string& path); static void WriteCbIO(uv_async_t* async); @@ -228,8 +227,8 @@ class AgentImpl { void InstallInspectorOnProcess(); void WorkerRunIO(); - void OnInspectorConnectionIO(inspector_socket_t* socket); - void OnRemoteDataIO(inspector_socket_t* stream, ssize_t read, + void OnInspectorConnectionIO(InspectorSocket* socket); + void OnRemoteDataIO(InspectorSocket* stream, ssize_t read, const uv_buf_t* b); void SetConnected(bool connected); void DispatchMessages(); @@ -255,7 +254,7 @@ class AgentImpl { uv_async_t* data_written_; uv_async_t io_thread_req_; - inspector_socket_t* client_socket_; + InspectorSocket* client_socket_; V8NodeInspector* inspector_; v8::Platform* platform_; MessageQueue incoming_message_queue_; @@ -281,7 +280,7 @@ void InterruptCallback(v8::Isolate*, void* agent) { } void DataCallback(uv_stream_t* stream, ssize_t read, const uv_buf_t* buf) { - inspector_socket_t* socket = inspector_from_stream(stream); + InspectorSocket* socket = inspector_from_stream(stream); static_cast(socket->data)->OnRemoteDataIO(socket, read, buf); } @@ -594,7 +593,7 @@ void AgentImpl::ThreadCbIO(void* agent) { // static void AgentImpl::OnSocketConnectionIO(uv_stream_t* server, int status) { if (status == 0) { - inspector_socket_t* socket = new inspector_socket_t(); + InspectorSocket* socket = new InspectorSocket(); socket->data = server->data; if (inspector_accept(server, socket, AgentImpl::OnInspectorHandshakeIO) != 0) { @@ -604,7 +603,7 @@ void AgentImpl::OnSocketConnectionIO(uv_stream_t* server, int status) { } // static -bool AgentImpl::OnInspectorHandshakeIO(inspector_socket_t* socket, +bool AgentImpl::OnInspectorHandshakeIO(InspectorSocket* socket, enum inspector_handshake_event state, const std::string& path) { AgentImpl* agent = static_cast(socket->data); @@ -626,7 +625,7 @@ bool AgentImpl::OnInspectorHandshakeIO(inspector_socket_t* socket, } } -void AgentImpl::OnRemoteDataIO(inspector_socket_t* socket, +void AgentImpl::OnRemoteDataIO(InspectorSocket* socket, ssize_t read, const uv_buf_t* buf) { Mutex::ScopedLock scoped_lock(pause_lock_); @@ -660,7 +659,7 @@ void AgentImpl::OnRemoteDataIO(inspector_socket_t* socket, // static void AgentImpl::WriteCbIO(uv_async_t* async) { AgentImpl* agent = static_cast(async->data); - inspector_socket_t* socket = agent->client_socket_; + InspectorSocket* socket = agent->client_socket_; if (socket) { MessageQueue outgoing_messages; agent->SwapBehindLock(&agent->outgoing_message_queue_, &outgoing_messages); @@ -741,7 +740,7 @@ void AgentImpl::PostIncomingMessage(const String16& message) { } } -void AgentImpl::OnInspectorConnectionIO(inspector_socket_t* socket) { +void AgentImpl::OnInspectorConnectionIO(InspectorSocket* socket) { if (client_socket_) { DisconnectAndDisposeIO(socket); return; diff --git a/src/inspector_socket.cc b/src/inspector_socket.cc index 5160843ff2dfe6..6edc08248b6a85 100644 --- a/src/inspector_socket.cc +++ b/src/inspector_socket.cc @@ -16,6 +16,9 @@ #define DUMP_READS 0 #define DUMP_WRITES 0 +namespace node { +namespace inspector { + static const char CLOSE_FRAME[] = {'\x88', '\x00'}; enum ws_decode_result { @@ -53,7 +56,7 @@ static void remove_from_beginning(std::vector* buffer, size_t count) { } static void dispose_inspector(uv_handle_t* handle) { - inspector_socket_t* inspector = inspector_from_stream(handle); + InspectorSocket* inspector = inspector_from_stream(handle); inspector_cb close = inspector->ws_mode ? inspector->ws_state->close_cb : nullptr; inspector->buffer.clear(); @@ -64,7 +67,7 @@ static void dispose_inspector(uv_handle_t* handle) { } } -static void close_connection(inspector_socket_t* inspector) { +static void close_connection(InspectorSocket* inspector) { uv_handle_t* socket = reinterpret_cast(&inspector->client); if (!uv_is_closing(socket)) { uv_read_stop(reinterpret_cast(socket)); @@ -73,7 +76,7 @@ static void close_connection(inspector_socket_t* inspector) { } struct WriteRequest { - WriteRequest(inspector_socket_t* inspector, const char* data, size_t size) + WriteRequest(InspectorSocket* inspector, const char* data, size_t size) : inspector(inspector) , storage(data, data + size) , buf(uv_buf_init(&storage[0], storage.size())) {} @@ -82,7 +85,7 @@ struct WriteRequest { return node::ContainerOf(&WriteRequest::req, req); } - inspector_socket_t* const inspector; + InspectorSocket* const inspector; std::vector storage; uv_write_t req; uv_buf_t buf; @@ -93,7 +96,7 @@ static void write_request_cleanup(uv_write_t* req, int status) { delete WriteRequest::from_write_req(req); } -static int write_to_client(inspector_socket_t* inspector, +static int write_to_client(InspectorSocket* inspector, const char* msg, size_t len, uv_write_cb write_cb = write_request_cleanup) { @@ -246,7 +249,7 @@ static ws_decode_result decode_frame_hybi17(const std::vector& buffer, return closed ? FRAME_CLOSE : FRAME_OK; } -static void invoke_read_callback(inspector_socket_t* inspector, +static void invoke_read_callback(InspectorSocket* inspector, int status, const uv_buf_t* buf) { if (inspector->ws_state->read_cb) { inspector->ws_state->read_cb( @@ -254,13 +257,13 @@ static void invoke_read_callback(inspector_socket_t* inspector, } } -static void shutdown_complete(inspector_socket_t* inspector) { +static void shutdown_complete(InspectorSocket* inspector) { close_connection(inspector); } static void on_close_frame_written(uv_write_t* req, int status) { WriteRequest* wr = WriteRequest::from_write_req(req); - inspector_socket_t* inspector = wr->inspector; + InspectorSocket* inspector = wr->inspector; delete wr; inspector->ws_state->close_sent = true; if (inspector->ws_state->received_close) { @@ -268,7 +271,7 @@ static void on_close_frame_written(uv_write_t* req, int status) { } } -static void close_frame_received(inspector_socket_t* inspector) { +static void close_frame_received(InspectorSocket* inspector) { inspector->ws_state->received_close = true; if (!inspector->ws_state->close_sent) { invoke_read_callback(inspector, 0, 0); @@ -279,7 +282,7 @@ static void close_frame_received(inspector_socket_t* inspector) { } } -static int parse_ws_frames(inspector_socket_t* inspector) { +static int parse_ws_frames(InspectorSocket* inspector) { int bytes_consumed = 0; std::vector output; bool compressed = false; @@ -314,7 +317,7 @@ static void prepare_buffer(uv_handle_t* stream, size_t len, uv_buf_t* buf) { *buf = uv_buf_init(new char[len], len); } -static void reclaim_uv_buf(inspector_socket_t* inspector, const uv_buf_t* buf, +static void reclaim_uv_buf(InspectorSocket* inspector, const uv_buf_t* buf, ssize_t read) { if (read > 0) { std::vector& buffer = inspector->buffer; @@ -325,7 +328,7 @@ static void reclaim_uv_buf(inspector_socket_t* inspector, const uv_buf_t* buf, static void websockets_data_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { - inspector_socket_t* inspector = inspector_from_stream(stream); + InspectorSocket* inspector = inspector_from_stream(stream); reclaim_uv_buf(inspector, buf, nread); if (nread < 0 || nread == UV_EOF) { inspector->connection_eof = true; @@ -352,7 +355,7 @@ static void websockets_data_cb(uv_stream_t* stream, ssize_t nread, } } -int inspector_read_start(inspector_socket_t* inspector, +int inspector_read_start(InspectorSocket* inspector, uv_alloc_cb alloc_cb, uv_read_cb read_cb) { ASSERT(inspector->ws_mode); ASSERT(!inspector->shutting_down || read_cb == nullptr); @@ -369,7 +372,7 @@ int inspector_read_start(inspector_socket_t* inspector, return err; } -void inspector_read_stop(inspector_socket_t* inspector) { +void inspector_read_stop(InspectorSocket* inspector) { uv_read_stop(reinterpret_cast(&inspector->client)); inspector->ws_state->alloc_cb = nullptr; inspector->ws_state->read_cb = nullptr; @@ -388,7 +391,7 @@ static void generate_accept_string(const std::string& client_key, static int header_value_cb(http_parser* parser, const char* at, size_t length) { static const char SEC_WEBSOCKET_KEY_HEADER[] = "Sec-WebSocket-Key"; - auto inspector = static_cast(parser->data); + auto inspector = static_cast(parser->data); auto state = inspector->http_parsing_state; state->parsing_value = true; if (state->current_header.size() == sizeof(SEC_WEBSOCKET_KEY_HEADER) - 1 && @@ -401,7 +404,7 @@ static int header_value_cb(http_parser* parser, const char* at, size_t length) { } static int header_field_cb(http_parser* parser, const char* at, size_t length) { - auto inspector = static_cast(parser->data); + auto inspector = static_cast(parser->data); auto state = inspector->http_parsing_state; if (state->parsing_value) { state->parsing_value = false; @@ -412,13 +415,13 @@ static int header_field_cb(http_parser* parser, const char* at, size_t length) { } static int path_cb(http_parser* parser, const char* at, size_t length) { - auto inspector = static_cast(parser->data); + auto inspector = static_cast(parser->data); auto state = inspector->http_parsing_state; state->path.append(at, length); return 0; } -static void handshake_complete(inspector_socket_t* inspector) { +static void handshake_complete(InspectorSocket* inspector) { uv_read_stop(reinterpret_cast(&inspector->client)); handshake_cb callback = inspector->http_parsing_state->callback; inspector->ws_state = new ws_state_s(); @@ -427,20 +430,20 @@ static void handshake_complete(inspector_socket_t* inspector) { inspector->http_parsing_state->path); } -static void cleanup_http_parsing_state(inspector_socket_t* inspector) { +static void cleanup_http_parsing_state(InspectorSocket* inspector) { delete inspector->http_parsing_state; inspector->http_parsing_state = nullptr; } static void report_handshake_failure_cb(uv_handle_t* handle) { dispose_inspector(handle); - inspector_socket_t* inspector = inspector_from_stream(handle); + InspectorSocket* inspector = inspector_from_stream(handle); handshake_cb cb = inspector->http_parsing_state->callback; cleanup_http_parsing_state(inspector); cb(inspector, kInspectorHandshakeFailed, std::string()); } -static void close_and_report_handshake_failure(inspector_socket_t* inspector) { +static void close_and_report_handshake_failure(InspectorSocket* inspector) { uv_handle_t* socket = reinterpret_cast(&inspector->client); if (uv_is_closing(socket)) { report_handshake_failure_cb(socket); @@ -451,12 +454,12 @@ static void close_and_report_handshake_failure(inspector_socket_t* inspector) { } static void then_close_and_report_failure(uv_write_t* req, int status) { - inspector_socket_t* inspector = WriteRequest::from_write_req(req)->inspector; + InspectorSocket* inspector = WriteRequest::from_write_req(req)->inspector; write_request_cleanup(req, status); close_and_report_handshake_failure(inspector); } -static void handshake_failed(inspector_socket_t* inspector) { +static void handshake_failed(InspectorSocket* inspector) { const char HANDSHAKE_FAILED_RESPONSE[] = "HTTP/1.0 400 Bad Request\r\n" "Content-Type: text/html; charset=UTF-8\r\n\r\n" @@ -467,11 +470,10 @@ static void handshake_failed(inspector_socket_t* inspector) { } // init_handshake references message_complete_cb -static void init_handshake(inspector_socket_t* inspector); +static void init_handshake(InspectorSocket* inspector); static int message_complete_cb(http_parser* parser) { - inspector_socket_t* inspector = - reinterpret_cast(parser->data); + InspectorSocket* inspector = static_cast(parser->data); struct http_parsing_state_s* state = inspector->http_parsing_state; if (parser->method != HTTP_GET) { handshake_failed(inspector); @@ -517,7 +519,7 @@ static void data_received_cb(uv_stream_s* client, ssize_t nread, printf("[%s:%d] %s\n", __FUNCTION__, __LINE__, uv_err_name(nread)); } #endif - inspector_socket_t* inspector = inspector_from_stream(client); + InspectorSocket* inspector = inspector_from_stream(client); reclaim_uv_buf(inspector, buf, nread); if (nread < 0 || nread == UV_EOF) { close_and_report_handshake_failure(inspector); @@ -536,7 +538,7 @@ static void data_received_cb(uv_stream_s* client, ssize_t nread, } } -static void init_handshake(inspector_socket_t* inspector) { +static void init_handshake(InspectorSocket* inspector) { http_parsing_state_s* state = inspector->http_parsing_state; CHECK_NE(state, nullptr); state->current_header.clear(); @@ -553,13 +555,13 @@ static void init_handshake(inspector_socket_t* inspector) { settings->on_url = path_cb; } -int inspector_accept(uv_stream_t* server, inspector_socket_t* inspector, +int inspector_accept(uv_stream_t* server, InspectorSocket* inspector, handshake_cb callback) { ASSERT_NE(callback, nullptr); CHECK_EQ(inspector->http_parsing_state, nullptr); + inspector->http_parsing_state = new http_parsing_state_s(); uv_stream_t* client = reinterpret_cast(&inspector->client); - CHECK_NE(client, nullptr); int err = uv_tcp_init(server->loop, &inspector->client); if (err == 0) { @@ -577,7 +579,7 @@ int inspector_accept(uv_stream_t* server, inspector_socket_t* inspector, return err; } -void inspector_write(inspector_socket_t* inspector, const char* data, +void inspector_write(InspectorSocket* inspector, const char* data, size_t len) { if (inspector->ws_mode) { std::vector output = encode_frame_hybi17(data, len); @@ -587,7 +589,7 @@ void inspector_write(inspector_socket_t* inspector, const char* data, } } -void inspector_close(inspector_socket_t* inspector, +void inspector_close(InspectorSocket* inspector, inspector_cb callback) { // libuv throws assertions when closing stream that's already closed - we // need to do the same. @@ -605,8 +607,20 @@ void inspector_close(inspector_socket_t* inspector, } } -bool inspector_is_active(const struct inspector_socket_s* inspector) { +bool inspector_is_active(const InspectorSocket* inspector) { const uv_handle_t* client = reinterpret_cast(&inspector->client); return !inspector->shutting_down && !uv_is_closing(client); } + +void InspectorSocket::reinit() { + http_parsing_state = nullptr; + ws_state = nullptr; + buffer.clear(); + ws_mode = false; + shutting_down = false; + connection_eof = false; +} + +} // namespace inspector +} // namespace node diff --git a/src/inspector_socket.h b/src/inspector_socket.h index de57d09e98eebb..558d87bcb76bf1 100644 --- a/src/inspector_socket.h +++ b/src/inspector_socket.h @@ -9,6 +9,9 @@ #include #include +namespace node { +namespace inspector { + enum inspector_handshake_event { kInspectorHandshakeUpgrading, kInspectorHandshakeUpgraded, @@ -16,13 +19,13 @@ enum inspector_handshake_event { kInspectorHandshakeFailed }; -struct inspector_socket_s; +class InspectorSocket; -typedef void (*inspector_cb)(struct inspector_socket_s*, int); +typedef void (*inspector_cb)(InspectorSocket*, int); // Notifies as handshake is progressing. Returning false as a response to // kInspectorHandshakeUpgrading or kInspectorHandshakeHttpGet event will abort // the connection. inspector_write can be used from the callback. -typedef bool (*handshake_cb)(struct inspector_socket_s*, +typedef bool (*handshake_cb)(InspectorSocket*, enum inspector_handshake_event state, const std::string& path); @@ -45,7 +48,12 @@ struct ws_state_s { bool received_close; }; -struct inspector_socket_s { +class InspectorSocket { + public: + InspectorSocket() : data(nullptr), http_parsing_state(nullptr), + ws_state(nullptr), buffer(0), ws_mode(false), + shutting_down(false), connection_eof(false) { } + void reinit(); void* data; struct http_parsing_state_s* http_parsing_state; struct ws_state_s* ws_state; @@ -54,35 +62,39 @@ struct inspector_socket_s { bool ws_mode; bool shutting_down; bool connection_eof; + private: + DISALLOW_COPY_AND_ASSIGN(InspectorSocket); }; -typedef struct inspector_socket_s inspector_socket_t; - -int inspector_accept(uv_stream_t* server, struct inspector_socket_s* inspector, +int inspector_accept(uv_stream_t* server, InspectorSocket* inspector, handshake_cb callback); -void inspector_close(struct inspector_socket_s* inspector, +void inspector_close(InspectorSocket* inspector, inspector_cb callback); // Callbacks will receive stream handles. Use inspector_from_stream to get -// inspector_socket_t* from the stream handle. -int inspector_read_start(struct inspector_socket_s* inspector, uv_alloc_cb, +// InspectorSocket* from the stream handle. +int inspector_read_start(InspectorSocket* inspector, uv_alloc_cb, uv_read_cb); -void inspector_read_stop(struct inspector_socket_s* inspector); -void inspector_write(struct inspector_socket_s* inspector, +void inspector_read_stop(InspectorSocket* inspector); +void inspector_write(InspectorSocket* inspector, const char* data, size_t len); -bool inspector_is_active(const struct inspector_socket_s* inspector); +bool inspector_is_active(const InspectorSocket* inspector); -inline inspector_socket_t* inspector_from_stream(uv_tcp_t* stream) { - return node::ContainerOf(&inspector_socket_t::client, stream); +inline InspectorSocket* inspector_from_stream(uv_tcp_t* stream) { + return node::ContainerOf(&InspectorSocket::client, stream); } -inline inspector_socket_t* inspector_from_stream(uv_stream_t* stream) { +inline InspectorSocket* inspector_from_stream(uv_stream_t* stream) { return inspector_from_stream(reinterpret_cast(stream)); } -inline inspector_socket_t* inspector_from_stream(uv_handle_t* stream) { +inline InspectorSocket* inspector_from_stream(uv_handle_t* stream) { return inspector_from_stream(reinterpret_cast(stream)); } +} // namespace inspector +} // namespace node + + #endif // SRC_INSPECTOR_SOCKET_H_ diff --git a/test/cctest/test_inspector_socket.cc b/test/cctest/test_inspector_socket.cc index 83e538be5a8889..f45593584abece 100644 --- a/test/cctest/test_inspector_socket.cc +++ b/test/cctest/test_inspector_socket.cc @@ -4,6 +4,8 @@ #define PORT 9444 +using namespace node::inspector; + static const int MAX_LOOP_ITERATIONS = 10000; #define SPIN_WHILE(condition) \ @@ -23,7 +25,7 @@ static int handshake_events = 0; static enum inspector_handshake_event last_event = kInspectorHandshakeHttpGet; static uv_loop_t loop; static uv_tcp_t server, client_socket; -static inspector_socket_t inspector; +static InspectorSocket inspector; static std::string last_path; static void (*handshake_delegate)(enum inspector_handshake_event state, const std::string& path, @@ -76,7 +78,7 @@ static void stop_if_stop_path(enum inspector_handshake_event state, *cont = path.empty() || path != "/close"; } -static bool connected_cb(inspector_socket_t* socket, +static bool connected_cb(InspectorSocket* socket, enum inspector_handshake_event state, const std::string& path) { inspector_ready = state == kInspectorHandshakeUpgraded; @@ -95,7 +97,7 @@ static bool connected_cb(inspector_socket_t* socket, static void on_new_connection(uv_stream_t* server, int status) { GTEST_ASSERT_EQ(0, status); connected = true; - inspector_accept(server, reinterpret_cast(server->data), + inspector_accept(server, static_cast(server->data), connected_cb); } @@ -276,7 +278,7 @@ static void expect_on_server(const char* data, size_t len) { static void inspector_record_error_code(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { - inspector_socket_t *inspector = inspector_from_stream(stream); + InspectorSocket *inspector = inspector_from_stream(stream); // Increment instead of assign is to ensure the function is only called once *(static_cast(inspector->data)) += nread; } @@ -336,13 +338,13 @@ static void on_connection(uv_connect_t* connect, int status) { class InspectorSocketTest : public ::testing::Test { protected: virtual void SetUp() { + inspector.reinit(); handshake_delegate = stop_if_stop_path; handshake_events = 0; connected = false; inspector_ready = false; last_event = kInspectorHandshakeHttpGet; uv_loop_init(&loop); - inspector = inspector_socket_t(); server = uv_tcp_t(); client_socket = uv_tcp_t(); server.data = &inspector; @@ -568,7 +570,7 @@ TEST_F(InspectorSocketTest, CanStopReadingFromInspector) { static int inspector_closed = 0; -void inspector_closed_cb(inspector_socket_t *inspector, int code) { +void inspector_closed_cb(InspectorSocket *inspector, int code) { inspector_closed++; } @@ -771,7 +773,7 @@ TEST_F(InspectorSocketTest, WriteBeforeHandshake) { SPIN_WHILE(inspector_closed == 0); } -static void CleanupSocketAfterEOF_close_cb(inspector_socket_t* inspector, +static void CleanupSocketAfterEOF_close_cb(InspectorSocket* inspector, int status) { *(static_cast(inspector->data)) = true; } @@ -779,7 +781,7 @@ static void CleanupSocketAfterEOF_close_cb(inspector_socket_t* inspector, static void CleanupSocketAfterEOF_read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { EXPECT_EQ(UV_EOF, nread); - inspector_socket_t* insp = inspector_from_stream(stream); + InspectorSocket* insp = inspector_from_stream(stream); inspector_close(insp, CleanupSocketAfterEOF_close_cb); }