bool SocketServer::tryBind(unsigned short port, const char * intface) { struct sockaddr_in servaddr; memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(port); if(intface != 0){ if(Ndb_getInAddr(&servaddr.sin_addr, intface)) return false; } const NDB_SOCKET_TYPE sock = my_socket_create(AF_INET, SOCK_STREAM, 0); if (!my_socket_valid(sock)) return false; DBUG_PRINT("info",("NDB_SOCKET: " MY_SOCKET_FORMAT, MY_SOCKET_FORMAT_VALUE(sock))); if (my_socket_reuseaddr(sock, true) == -1) { NDB_CLOSE_SOCKET(sock); return false; } if (my_bind_inet(sock, &servaddr) == -1) { NDB_CLOSE_SOCKET(sock); return false; } NDB_CLOSE_SOCKET(sock); return true; }
bool SocketServer::tryBind(unsigned short port, const char * intface) { struct sockaddr_in servaddr; memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(port); if(intface != 0){ if(Ndb_getInAddr(&servaddr.sin_addr, intface)) return false; } const NDB_SOCKET_TYPE sock = socket(AF_INET, SOCK_STREAM, 0); if (sock == NDB_INVALID_SOCKET) { return false; } DBUG_PRINT("info",("NDB_SOCKET: %d", sock)); const int on = 1; if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on)) == -1) { NDB_CLOSE_SOCKET(sock); return false; } if (bind(sock, (struct sockaddr*) &servaddr, sizeof(servaddr)) == -1) { NDB_CLOSE_SOCKET(sock); return false; } NDB_CLOSE_SOCKET(sock); return true; }
bool SocketClient::init() { if (my_socket_valid(m_sockfd)) NDB_CLOSE_SOCKET(m_sockfd); if (m_server_name) { memset(&m_servaddr, 0, sizeof(m_servaddr)); m_servaddr.sin_family = AF_INET; m_servaddr.sin_port = htons(m_port); // Convert ip address presentation format to numeric format if (Ndb_getInAddr(&m_servaddr.sin_addr, m_server_name)) return false; } m_sockfd= my_socket_create(AF_INET, SOCK_STREAM, 0); if (!my_socket_valid(m_sockfd)) { return false; } DBUG_PRINT("info",("NDB_SOCKET: " MY_SOCKET_FORMAT, MY_SOCKET_FORMAT_VALUE(m_sockfd))); return true; }
SocketServer::Session * TransporterService::newSession(NDB_SOCKET_TYPE sockfd) { DBUG_ENTER("SocketServer::Session * TransporterService::newSession"); if (m_auth && !m_auth->server_authenticate(sockfd)){ NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(0); } if (!m_transporter_registry->connect_server(sockfd)) { NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(0); } DBUG_RETURN(0); }
void Ndb_mgmd_event_service::check_listeners() { int i, n= 0; DBUG_ENTER("Ndb_mgmd_event_service::check_listeners"); m_clients.lock(); for(i= m_clients.size() - 1; i >= 0; i--) { if(m_clients[i].m_socket==NDB_INVALID_SOCKET) continue; SocketOutputStream out(m_clients[i].m_socket); DBUG_PRINT("info",("%d %d",i,m_clients[i].m_socket)); if(out.println("<PING>") < 0) { NDB_CLOSE_SOCKET(m_clients[i].m_socket); m_clients.erase(i, false); n=1; } } if (n) { LogLevel tmp; tmp.clear(); for(i= m_clients.size() - 1; i >= 0; i--) tmp.set_max(m_clients[i].m_logLevel); update_log_level(tmp); } m_clients.unlock(); DBUG_VOID_RETURN; }
SocketClient::~SocketClient() { if (m_server_name) free(m_server_name); if (my_socket_valid(m_sockfd)) NDB_CLOSE_SOCKET(m_sockfd); if (m_auth) delete m_auth; }
void Ndb_mgmd_event_service::stop_sessions(){ m_clients.lock(); for(int i = m_clients.size() - 1; i >= 0; i--){ if(m_clients[i].m_socket != NDB_INVALID_SOCKET){ NDB_CLOSE_SOCKET(m_clients[i].m_socket); m_clients.erase(i); } } m_clients.unlock(); }
SocketServer::~SocketServer() { unsigned i; for(i = 0; i<m_sessions.size(); i++){ delete m_sessions[i].m_session; } for(i = 0; i<m_services.size(); i++){ if(m_services[i].m_socket) NDB_CLOSE_SOCKET(m_services[i].m_socket); delete m_services[i].m_service; } }
bool SCI_Transporter::connect_server_impl(NDB_SOCKET_TYPE sockfd) { SocketOutputStream s_output(sockfd); SocketInputStream s_input(sockfd); char buf[256]; DBUG_ENTER("SCI_Transporter::connect_server_impl"); if (!init_local()) { NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Send ok to client s_output.println("sci server 1 ok"); // Wait for ok from client if (s_input.gets(buf, 256) == 0) { DBUG_PRINT("error", ("No response from client in SCI")); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } if (!init_remote()) { NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Send ok to client s_output.println("sci server 2 ok"); // Wait for ok from client if (s_input.gets(buf, 256) == 0) { DBUG_PRINT("error", ("No second response from client in SCI")); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("info", ("Successfully connected server to node %d", remoteNodeId)); DBUG_RETURN(true); }
void TCP_Transporter::disconnectImpl() { if(theSocket != NDB_INVALID_SOCKET){ if(NDB_CLOSE_SOCKET(theSocket) < 0){ report_error(TE_ERROR_CLOSING_SOCKET); } } // Empty send och receive buffers receiveBuffer.clear(); m_sendBuffer.emptyBuffer(); theSocket = NDB_INVALID_SOCKET; }
void* sessionThread_C(void* _sc){ SocketServer::Session * si = (SocketServer::Session *)_sc; assert(si->m_thread_stopped == false); if(!si->m_stop) si->runSession(); else NDB_CLOSE_SOCKET(si->m_socket); // Mark the thread as stopped to allow the // session resources to be released si->m_thread_stopped = true; return 0; }
void MgmApiSession::runSession() { DBUG_ENTER("MgmApiSession::runSession"); Parser_t::Context ctx; ctx.m_mutex= m_mutex; m_ctx= &ctx; bool stop= false; while(!stop) { NdbMutex_Lock(m_mutex); m_input->reset_timeout(); m_output->reset_timeout(); m_parser->run(ctx, *this); if(ctx.m_currentToken == 0) { NdbMutex_Unlock(m_mutex); break; } switch(ctx.m_status) { case Parser_t::UnknownCommand: break; default: break; } stop= m_stop; NdbMutex_Unlock(m_mutex); }; NdbMutex_Lock(m_mutex); m_ctx= NULL; if(m_socket != NDB_INVALID_SOCKET) { NDB_CLOSE_SOCKET(m_socket); m_socket= NDB_INVALID_SOCKET; } NdbMutex_Unlock(m_mutex); DBUG_VOID_RETURN; }
void* sessionThread_C(void* _sc){ SocketServer::Session * si = (SocketServer::Session *)_sc; /** * may have m_stopped set if we're transforming a mgm * connection into a transporter connection. */ if(!si->m_stopped) { if(!si->m_stop){ si->m_stopped = false; si->runSession(); } else { NDB_CLOSE_SOCKET(si->m_socket); } } si->m_stopped = true; return 0; }
void CPCDAPISession::runSession(){ Parser_t::Context ctx; while(!m_stop){ m_parser->run(ctx, * this); if(ctx.m_currentToken == 0) break; switch(ctx.m_status){ case Parser_t::Ok: for(size_t i = 0; i<ctx.m_aliasUsed.size(); i++) ndbout_c("Used alias: %s -> %s", ctx.m_aliasUsed[i]->name, ctx.m_aliasUsed[i]->realName); break; case Parser_t::NoLine: case Parser_t::EmptyLine: break; default: break; } } NDB_CLOSE_SOCKET(m_socket); }
MgmApiSession::~MgmApiSession() { DBUG_ENTER("MgmApiSession::~MgmApiSession"); if (m_input) delete m_input; if (m_output) delete m_output; if (m_parser) delete m_parser; if (m_allocated_resources) delete m_allocated_resources; if(m_socket != NDB_INVALID_SOCKET) { NDB_CLOSE_SOCKET(m_socket); m_socket= NDB_INVALID_SOCKET; } if(m_stopSelf < 0) g_RestartServer= true; if(m_stopSelf) g_StopServer= true; NdbMutex_Destroy(m_mutex); DBUG_VOID_RETURN; }
bool SocketServer::setup(SocketServer::Service * service, unsigned short * port, const char * intface){ DBUG_ENTER("SocketServer::setup"); DBUG_PRINT("enter",("interface=%s, port=%u", intface, *port)); struct sockaddr_in servaddr; memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(*port); if(intface != 0){ if(Ndb_getInAddr(&servaddr.sin_addr, intface)) DBUG_RETURN(false); } const NDB_SOCKET_TYPE sock = my_socket_create(AF_INET, SOCK_STREAM, 0); if (!my_socket_valid(sock)) { DBUG_PRINT("error",("socket() - %d - %s", socket_errno, strerror(socket_errno))); DBUG_RETURN(false); } DBUG_PRINT("info",("NDB_SOCKET: " MY_SOCKET_FORMAT, MY_SOCKET_FORMAT_VALUE(sock))); if (my_socket_reuseaddr(sock, true) == -1) { DBUG_PRINT("error",("setsockopt() - %d - %s", errno, strerror(errno))); NDB_CLOSE_SOCKET(sock); DBUG_RETURN(false); } if (my_bind_inet(sock, &servaddr) == -1) { DBUG_PRINT("error",("bind() - %d - %s", socket_errno, strerror(socket_errno))); NDB_CLOSE_SOCKET(sock); DBUG_RETURN(false); } /* Get the port we bound to */ if(my_socket_get_port(sock, port)) { ndbout_c("An error occurred while trying to find out what" " port we bound to. Error: %d - %s", socket_errno, strerror(socket_errno)); my_socket_close(sock); DBUG_RETURN(false); } DBUG_PRINT("info",("bound to %u", *port)); if (my_listen(sock, m_maxSessions > 32 ? 32 : m_maxSessions) == -1) { DBUG_PRINT("error",("listen() - %d - %s", socket_errno, strerror(socket_errno))); my_socket_close(sock); DBUG_RETURN(false); } ServiceInstance i; i.m_socket = sock; i.m_service = service; m_services.push_back(i); // Increase size to allow polling all listening ports m_services_poller.set_max_count(m_services.size()); DBUG_RETURN(true); }
bool Transporter::connect_client(NDB_SOCKET_TYPE sockfd) { if(m_connected) return true; if (sockfd == NDB_INVALID_SOCKET) return false; DBUG_ENTER("Transporter::connect_client"); DBUG_PRINT("info",("port %d isMgmConnection=%d",m_s_port,isMgmConnection)); SocketOutputStream s_output(sockfd); SocketInputStream s_input(sockfd); // send info about own id // send info about own transporter type s_output.println("%d %d", localNodeId, m_type); // get remote id int nodeId, remote_transporter_type= -1; char buf[256]; if (s_input.gets(buf, 256) == 0) { NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } int r= sscanf(buf, "%d %d", &nodeId, &remote_transporter_type); switch (r) { case 2: break; case 1: // we're running version prior to 4.1.9 // ok, but with no checks on transporter configuration compatability break; default: NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } DBUG_PRINT("info", ("nodeId=%d remote_transporter_type=%d", nodeId, remote_transporter_type)); if (remote_transporter_type != -1) { if (remote_transporter_type != m_type) { DBUG_PRINT("error", ("Transporter types mismatch this=%d remote=%d", m_type, remote_transporter_type)); NDB_CLOSE_SOCKET(sockfd); g_eventLogger.error("Incompatible configuration: transporter type " "mismatch with node %d", nodeId); DBUG_RETURN(false); } } else if (m_type == tt_SHM_TRANSPORTER) { g_eventLogger.warning("Unable to verify transporter compatability with node %d", nodeId); } { struct sockaddr_in addr; SOCKET_SIZE_TYPE addrlen= sizeof(addr); getpeername(sockfd, (struct sockaddr*)&addr, &addrlen); m_connect_address= (&addr)->sin_addr; } bool res = connect_client_impl(sockfd); if(res){ m_connected = true; m_errorCount = 0; } DBUG_RETURN(res); }
bool SocketServer::setup(SocketServer::Service * service, unsigned short * port, const char * intface){ DBUG_ENTER("SocketServer::setup"); DBUG_PRINT("enter",("interface=%s, port=%u", intface, *port)); struct sockaddr_in servaddr; memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(*port); if(intface != 0){ if(Ndb_getInAddr(&servaddr.sin_addr, intface)) DBUG_RETURN(false); } const NDB_SOCKET_TYPE sock = socket(AF_INET, SOCK_STREAM, 0); if (sock == NDB_INVALID_SOCKET) { DBUG_PRINT("error",("socket() - %d - %s", errno, strerror(errno))); DBUG_RETURN(false); } DBUG_PRINT("info",("NDB_SOCKET: %d", sock)); const int on = 1; if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on)) == -1) { DBUG_PRINT("error",("setsockopt() - %d - %s", errno, strerror(errno))); NDB_CLOSE_SOCKET(sock); DBUG_RETURN(false); } if (bind(sock, (struct sockaddr*) &servaddr, sizeof(servaddr)) == -1) { DBUG_PRINT("error",("bind() - %d - %s", errno, strerror(errno))); NDB_CLOSE_SOCKET(sock); DBUG_RETURN(false); } /* Get the port we bound to */ SOCKET_SIZE_TYPE sock_len = sizeof(servaddr); if(getsockname(sock,(struct sockaddr*)&servaddr,&sock_len)<0) { ndbout_c("An error occurred while trying to find out what" " port we bound to. Error: %s",strerror(errno)); NDB_CLOSE_SOCKET(sock); DBUG_RETURN(false); } DBUG_PRINT("info",("bound to %u",ntohs(servaddr.sin_port))); if (listen(sock, m_maxSessions > 32 ? 32 : m_maxSessions) == -1){ DBUG_PRINT("error",("listen() - %d - %s", errno, strerror(errno))); NDB_CLOSE_SOCKET(sock); DBUG_RETURN(false); } ServiceInstance i; i.m_socket = sock; i.m_service = service; m_services.push_back(i); *port = ntohs(servaddr.sin_port); DBUG_RETURN(true); }
bool Transporter::connect_client(NDB_SOCKET_TYPE sockfd) { DBUG_ENTER("Transporter::connect_client(sockfd)"); if(m_connected) { DBUG_PRINT("error", ("Already connected")); DBUG_RETURN(true); } if (!my_socket_valid(sockfd)) { DBUG_PRINT("error", ("Socket " MY_SOCKET_FORMAT " is not valid", MY_SOCKET_FORMAT_VALUE(sockfd))); DBUG_RETURN(false); } DBUG_PRINT("info",("server port: %d, isMgmConnection: %d", m_s_port, isMgmConnection)); // Send "hello" DBUG_PRINT("info", ("Sending own nodeid: %d and transporter type: %d", localNodeId, m_type)); SocketOutputStream s_output(sockfd); if (s_output.println("%d %d", localNodeId, m_type) < 0) { DBUG_PRINT("error", ("Send of 'hello' failed")); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Read reply DBUG_PRINT("info", ("Reading reply")); char buf[256]; SocketInputStream s_input(sockfd); if (s_input.gets(buf, 256) == 0) { DBUG_PRINT("error", ("Failed to read reply")); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Parse reply int nodeId, remote_transporter_type= -1; int r= sscanf(buf, "%d %d", &nodeId, &remote_transporter_type); switch (r) { case 2: break; case 1: // we're running version prior to 4.1.9 // ok, but with no checks on transporter configuration compatability break; default: DBUG_PRINT("error", ("Failed to parse reply")); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } DBUG_PRINT("info", ("nodeId=%d remote_transporter_type=%d", nodeId, remote_transporter_type)); // Check nodeid if (nodeId != remoteNodeId) { g_eventLogger->error("Connected to wrong nodeid: %d, expected: %d", nodeId, remoteNodeId); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Check transporter type if (remote_transporter_type != -1 && remote_transporter_type != m_type) { g_eventLogger->error("Connection to node: %d uses different transporter " "type: %d, expected type: %d", nodeId, remote_transporter_type, m_type); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Cache the connect address my_socket_connect_address(sockfd, &m_connect_address); if (!connect_client_impl(sockfd)) DBUG_RETURN(false); m_connected = true; DBUG_RETURN(true); }
bool SHM_Transporter::connect_client_impl(NDB_SOCKET_TYPE sockfd) { DBUG_ENTER("SHM_Transporter::connect_client_impl"); SocketInputStream s_input(sockfd); SocketOutputStream s_output(sockfd); char buf[256]; // Wait for server to create and attach DBUG_PRINT("info", ("Wait for server to create and attach")); if (s_input.gets(buf, 256) == 0) { NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("error", ("Server id %d did not attach", remoteNodeId)); DBUG_RETURN(false); } if(sscanf(buf, "shm server 1 ok: %d", &m_remote_pid) != 1) { NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Create if(!_shmSegCreated){ if (!ndb_shm_get()) { NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("error", ("Failed create of shm seg to node %d", remoteNodeId)); DBUG_RETURN(false); } _shmSegCreated = true; } // Attach if(!_attached){ if (!ndb_shm_attach()) { make_error_info(buf, sizeof(buf)); report_error(TE_SHM_UNABLE_TO_ATTACH_SEGMENT, buf); NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("error", ("Failed attach of shm seg to node %d", remoteNodeId)); DBUG_RETURN(false); } _attached = true; } // Send ok to server s_output.println("shm client 1 ok: %d", m_transporter_registry.m_shm_own_pid); int r= connect_common(sockfd); if (r) { // Wait for ok from server DBUG_PRINT("info", ("Wait for ok from server")); if (s_input.gets(buf, 256) == 0) { NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("error", ("No ok from server node %d", remoteNodeId)); DBUG_RETURN(false); } // Send ok to server s_output.println("shm client 2 ok"); DBUG_PRINT("info", ("Successfully connected client to node %d", remoteNodeId)); } NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(r); }
void Ndb_mgmd_event_service::log(int eventType, const Uint32* theData, NodeId nodeId){ Uint32 threshold; LogLevel::EventCategory cat; Logger::LoggerLevel severity; EventLoggerBase::EventTextFunction textF; int i, n; DBUG_ENTER("Ndb_mgmd_event_service::log"); DBUG_PRINT("enter",("eventType=%d, nodeid=%d", eventType, nodeId)); if (EventLoggerBase::event_lookup(eventType,cat,threshold,severity,textF)) DBUG_VOID_RETURN; char m_text[512]; EventLogger::getText(m_text, sizeof(m_text), textF, theData, nodeId); BaseString str("log event reply\n"); str.appfmt("type=%d\n", eventType); str.appfmt("time=%d\n", 0); str.appfmt("source_nodeid=%d\n", nodeId); for (i= 0; ndb_logevent_body[i].token; i++) { if ( ndb_logevent_body[i].type != eventType) continue; int val= theData[ndb_logevent_body[i].index]; if (ndb_logevent_body[i].index_fn) val= (*(ndb_logevent_body[i].index_fn))(val); str.appfmt("%s=%d\n",ndb_logevent_body[i].token, val); if(strcmp(ndb_logevent_body[i].token,"error") == 0) { int m_text_len= strlen(m_text); if(sizeof(m_text)-m_text_len-3 > 0) { BaseString::snprintf(m_text+m_text_len, 4 , " - "); ndb_error_string(val, m_text+(m_text_len+3), sizeof(m_text)-m_text_len-3); } } } Vector<NDB_SOCKET_TYPE> copy; m_clients.lock(); for(i = m_clients.size() - 1; i >= 0; i--) { if(threshold <= m_clients[i].m_logLevel.getLogLevel(cat)) { if(m_clients[i].m_socket==NDB_INVALID_SOCKET) continue; SocketOutputStream out(m_clients[i].m_socket); int r; if (m_clients[i].m_parsable) r= out.println(str.c_str()); else r= out.println(m_text); if (r<0) { copy.push_back(m_clients[i].m_socket); m_clients.erase(i, false); } } } m_clients.unlock(); if ((n= (int)copy.size())) { for(i= 0; i < n; i++) NDB_CLOSE_SOCKET(copy[i]); LogLevel tmp; tmp.clear(); m_clients.lock(); for(i= m_clients.size() - 1; i >= 0; i--) tmp.set_max(m_clients[i].m_logLevel); m_clients.unlock(); update_log_level(tmp); } DBUG_VOID_RETURN; }