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;
}
