void GeneralTab::inputChanged(int input)
{
s_input(input);
if (m_audioInput)
updateAudioInput();
updateVideoInput();
}
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);
}
bool SocketAuthSimple::client_authenticate(int sockfd)
{
SocketOutputStream s_output(sockfd);
SocketInputStream s_input(sockfd);
if (m_username)
s_output.println("%s", m_username);
else
s_output.println("");
if (m_passwd)
s_output.println("%s", m_passwd);
else
s_output.println("");
char buf[16];
if (s_input.gets(buf, 16) == 0) return false;
if (strncmp("ok", buf, 2) == 0)
return true;
return false;
}
bool SocketAuthSimple::server_authenticate(int sockfd)
{
SocketOutputStream s_output(sockfd);
SocketInputStream s_input(sockfd);
char buf[256];
if (s_input.gets(buf, 256) == 0) return false;
buf[255]= 0;
if (m_username)
free((void*)m_username);
m_username= strdup(buf);
if (s_input.gets(buf, 256) == 0) return false;
buf[255]= 0;
if (m_passwd)
free((void*)m_passwd);
m_passwd= strdup(buf);
s_output.println("ok");
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
TransporterRegistry::connect_server(NDB_SOCKET_TYPE sockfd)
{
DBUG_ENTER("TransporterRegistry::connect_server");
// read node id from client
// read transporter type
int nodeId, remote_transporter_type= -1;
SocketInputStream s_input(sockfd);
char buf[256];
if (s_input.gets(buf, 256) == 0) {
DBUG_PRINT("error", ("Could not get node id from client"));
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:
DBUG_PRINT("error", ("Error in node id from client"));
DBUG_RETURN(false);
}
DBUG_PRINT("info", ("nodeId=%d remote_transporter_type=%d",
nodeId,remote_transporter_type));
//check that nodeid is valid and that there is an allocated transporter
if ( nodeId < 0 || nodeId >= (int)maxTransporters) {
DBUG_PRINT("error", ("Node id out of range from client"));
DBUG_RETURN(false);
}
if (theTransporters[nodeId] == 0) {
DBUG_PRINT("error", ("No transporter for this node id from client"));
DBUG_RETURN(false);
}
//check that the transporter should be connected
if (performStates[nodeId] != TransporterRegistry::CONNECTING) {
DBUG_PRINT("error", ("Transporter in wrong state for this node id from client"));
DBUG_RETURN(false);
}
Transporter *t= theTransporters[nodeId];
// send info about own id (just as response to acknowledge connection)
// send info on own transporter type
SocketOutputStream s_output(sockfd);
s_output.println("%d %d", t->getLocalNodeId(), t->m_type);
if (remote_transporter_type != -1)
{
if (remote_transporter_type != t->m_type)
{
DBUG_PRINT("error", ("Transporter types mismatch this=%d remote=%d",
t->m_type, remote_transporter_type));
g_eventLogger.error("Incompatible configuration: Transporter type "
"mismatch with node %d", nodeId);
// wait for socket close for 1 second to let message arrive at client
{
fd_set a_set;
FD_ZERO(&a_set);
FD_SET(sockfd, &a_set);
struct timeval timeout;
timeout.tv_sec = 1; timeout.tv_usec = 0;
select(sockfd+1, &a_set, 0, 0, &timeout);
}
DBUG_RETURN(false);
}
}
else if (t->m_type == tt_SHM_TRANSPORTER)
{
g_eventLogger.warning("Unable to verify transporter compatability with node %d", nodeId);
}
// setup transporter (transporter responsible for closing sockfd)
t->connect_server(sockfd);
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);
}
