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;
}
void
Conn::conn0()
{
int fd;
while (1) {
if ((fd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
fatal("%s: create client socket failed: %s", info, strerror(errno));
}
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
servaddr.sin_addr = hostaddr.sin_addr;
#if 0 // coredump
if (Ndb_getInAddr(&servaddr.sin_addr, hostname) != 0) {
fatal("%s: hostname %s lookup failed", info, hostname);
}
#endif
if (connect(fd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == 0)
break;
if (errno != ECONNREFUSED) {
fatal("%s: connect failed: %s", info, strerror(errno));
}
close(fd);
NdbSleep_MilliSleep(100);
}
sockfd[0] = fd;
debug("%s: side 0 connected", info);
}
int
SocketClient::bind(const char* bindaddress, unsigned short localport)
{
if (!my_socket_valid(m_sockfd))
return -1;
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(localport);
// Convert ip address presentation format to numeric format
if (Ndb_getInAddr(&local.sin_addr, bindaddress))
{
return errno ? errno : EINVAL;
}
if (my_socket_reuseaddr(m_sockfd, true) == -1)
{
int ret = my_socket_errno();
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return ret;
}
if (my_bind_inet(m_sockfd, &local) == -1)
{
int ret = my_socket_errno();
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return ret;
}
return 0;
}
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;
}
int
main(int av, char** ac)
{
ndb_init();
debug("start");
hostname = "ndb-srv7";
if (Ndb_getInAddr(&hostaddr.sin_addr, hostname) != 0) {
fatal("hostname %s lookup failed", hostname);
}
localcfgfile = "Ndb.cfg";
initcfgfile = "config.txt";
getcfg();
start();
debug("done");
return 0;
}
Transporter::Transporter(TransporterRegistry &t_reg,
TransporterType _type,
const char *lHostName,
const char *rHostName,
int s_port,
bool _isMgmConnection,
NodeId lNodeId,
NodeId rNodeId,
NodeId serverNodeId,
int _byteorder,
bool _compression, bool _checksum, bool _signalId)
: m_s_port(s_port), remoteNodeId(rNodeId), localNodeId(lNodeId),
isServer(lNodeId==serverNodeId),
m_packer(_signalId, _checksum), isMgmConnection(_isMgmConnection),
m_type(_type),
m_transporter_registry(t_reg)
{
DBUG_ENTER("Transporter::Transporter");
if (rHostName && strlen(rHostName) > 0){
strncpy(remoteHostName, rHostName, sizeof(remoteHostName));
Ndb_getInAddr(&remoteHostAddress, rHostName);
}
else
{
if (!isServer) {
ndbout << "Unable to setup transporter. Node " << rNodeId
<< " must have hostname. Update configuration." << endl;
exit(-1);
}
remoteHostName[0]= 0;
}
strncpy(localHostName, lHostName, sizeof(localHostName));
DBUG_PRINT("info",("rId=%d lId=%d isServer=%d rHost=%s lHost=%s s_port=%d",
remoteNodeId, localNodeId, isServer,
remoteHostName, localHostName,
s_port));
byteOrder = _byteorder;
compressionUsed = _compression;
checksumUsed = _checksum;
signalIdUsed = _signalId;
m_connected = false;
m_timeOutMillis = 30000;
m_connect_address.s_addr= 0;
if(s_port<0)
s_port= -s_port; // was dynamic
if (isServer)
m_socket_client= 0;
else
{
m_socket_client= new SocketClient(remoteHostName, s_port,
new SocketAuthSimple("ndbd",
"ndbd passwd"));
m_socket_client->set_connect_timeout((m_timeOutMillis+999)/1000);
}
DBUG_VOID_RETURN;
}
Transporter::Transporter(TransporterRegistry &t_reg,
TransporterType _type,
const char *lHostName,
const char *rHostName,
int s_port,
bool _isMgmConnection,
NodeId lNodeId,
NodeId rNodeId,
NodeId serverNodeId,
int _byteorder,
bool _compression, bool _checksum, bool _signalId,
Uint32 max_send_buffer)
: m_s_port(s_port), remoteNodeId(rNodeId), localNodeId(lNodeId),
isServer(lNodeId==serverNodeId),
m_packer(_signalId, _checksum), m_max_send_buffer(max_send_buffer),
m_overload_limit(0xFFFFFFFF), isMgmConnection(_isMgmConnection),
m_connected(false),
m_type(_type),
m_transporter_registry(t_reg)
{
DBUG_ENTER("Transporter::Transporter");
if (rHostName && strlen(rHostName) > 0){
strncpy(remoteHostName, rHostName, sizeof(remoteHostName));
Ndb_getInAddr(&remoteHostAddress, rHostName);
}
else
{
if (!isServer) {
ndbout << "Unable to setup transporter. Node " << rNodeId
<< " must have hostname. Update configuration." << endl;
exit(-1);
}
remoteHostName[0]= 0;
}
strncpy(localHostName, lHostName, sizeof(localHostName));
DBUG_PRINT("info",("rId=%d lId=%d isServer=%d rHost=%s lHost=%s s_port=%d",
remoteNodeId, localNodeId, isServer,
remoteHostName, localHostName,
s_port));
byteOrder = _byteorder;
compressionUsed = _compression;
checksumUsed = _checksum;
signalIdUsed = _signalId;
m_timeOutMillis = 30000;
m_connect_address.s_addr= 0;
if(s_port<0)
s_port= -s_port; // was dynamic
if (isServer)
m_socket_client= 0;
else
{
m_socket_client= new SocketClient(remoteHostName, s_port,
new SocketAuthSimple("ndbd",
"ndbd passwd"));
m_socket_client->set_connect_timeout(m_timeOutMillis);
}
m_os_max_iovec = 16;
#if defined (_SC_IOV_MAX) && defined (HAVE_SYSCONF)
long res = sysconf(_SC_IOV_MAX);
if (res != (long)-1)
{
m_os_max_iovec = (Uint32)res;
}
#endif
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);
}
static void
statReport(enum StartType st, int ops)
{
if (!statEnable)
return;
if (NdbMutex_Lock(&statMutex) < 0) {
if (statState != statError) {
ndbout_c("stat: lock mutex failed: %s", strerror(errno));
statState = statError;
}
return;
}
static int nodeid;
// open connection
if (statState != statOpen) {
char *p = getenv("NDB_NODEID"); // ndbnet sets NDB_NODEID
nodeid = p == 0 ? 0 : atoi(p);
if ((statSock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
if (statState != statError) {
ndbout_c("stat: create socket failed: %s", strerror(errno));
statState = statError;
}
(void)NdbMutex_Unlock(&statMutex);
return;
}
struct sockaddr_in saddr;
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(statPort);
if (Ndb_getInAddr(&saddr.sin_addr, statHost) < 0) {
if (statState != statError) {
ndbout_c("stat: host %s not found", statHost);
statState = statError;
}
(void)close(statSock);
(void)NdbMutex_Unlock(&statMutex);
return;
}
if (connect(statSock, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
if (statState != statError) {
ndbout_c("stat: connect failed: %s", strerror(errno));
statState = statError;
}
(void)close(statSock);
(void)NdbMutex_Unlock(&statMutex);
return;
}
statState = statOpen;
ndbout_c("stat: connection to %s:%d opened", statHost, (int)statPort);
}
const char *text;
switch (st) {
case stInsert:
text = "insert";
break;
case stVerify:
text = "verify";
break;
case stRead:
text = "read";
break;
case stUpdate:
text = "update";
break;
case stDelete:
text = "delete";
break;
case stVerifyDelete:
text = "verifydelete";
break;
default:
text = "unknown";
break;
}
char buf[100];
sprintf(buf, "%d %s %d\n", nodeid, text, ops);
int len = strlen(buf);
// assume SIGPIPE already ignored
if (write(statSock, buf, len) != len) {
if (statState != statError) {
ndbout_c("stat: write failed: %s", strerror(errno));
statState = statError;
}
(void)close(statSock);
(void)NdbMutex_Unlock(&statMutex);
return;
}
(void)NdbMutex_Unlock(&statMutex);
}
NDB_SOCKET_TYPE
SocketClient::connect(const char *toaddress, unsigned short toport)
{
if (!my_socket_valid(m_sockfd))
{
if (!init())
{
return m_sockfd;
}
}
if (toaddress)
{
if (m_server_name)
free(m_server_name);
m_server_name = strdup(toaddress);
m_port = toport;
memset(&m_servaddr, 0, sizeof(m_servaddr));
m_servaddr.sin_family = AF_INET;
m_servaddr.sin_port = htons(toport);
// Convert ip address presentation format to numeric format
if (Ndb_getInAddr(&m_servaddr.sin_addr, m_server_name))
{
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return m_sockfd;
}
}
// Set socket non blocking
if (my_socket_nonblock(m_sockfd, true) < 0)
{
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return m_sockfd;
}
// Start non blocking connect
int r = my_connect_inet(m_sockfd, &m_servaddr);
if (r == 0)
goto done; // connected immediately.
if (r < 0 && NONBLOCKERR(my_socket_errno())) {
// Start of non blocking connect failed
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return m_sockfd;
}
if (ndb_poll(m_sockfd, true, true, true,
m_connect_timeout_millisec > 0 ?
m_connect_timeout_millisec : -1) <= 0)
{
// Nothing has happened on the socket after timeout
// or an error occured
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return m_sockfd;
}
// Activity detected on the socket
{
// Check socket level error code
int so_error = 0;
SOCKET_SIZE_TYPE len= sizeof(so_error);
if (my_getsockopt(m_sockfd, SOL_SOCKET, SO_ERROR, &so_error, &len) < 0)
{
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return m_sockfd;
}
if (so_error)
{
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return m_sockfd;
}
}
done:
if (my_socket_nonblock(m_sockfd, true) < 0)
{
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return m_sockfd;
}
if (m_auth) {
if (!m_auth->client_authenticate(m_sockfd))
{
my_socket_close(m_sockfd);
my_socket_invalidate(&m_sockfd);
return m_sockfd;
}
}
NDB_SOCKET_TYPE sockfd = m_sockfd;
my_socket_invalidate(&m_sockfd);
return sockfd;
}
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
ConfigRetriever::verifyConfig(const struct ndb_mgm_configuration * conf, Uint32 nodeid){
char buf[255];
ndb_mgm_configuration_iterator * it;
it = ndb_mgm_create_configuration_iterator((struct ndb_mgm_configuration *)conf,
CFG_SECTION_NODE);
if(it == 0){
BaseString::snprintf(buf, 255, "Unable to create config iterator");
setError(CR_ERROR, buf);
return false;
}
NdbAutoPtr<ndb_mgm_configuration_iterator> ptr(it);
if(ndb_mgm_find(it, CFG_NODE_ID, nodeid) != 0){
BaseString::snprintf(buf, 255, "Unable to find node with id: %d", nodeid);
setError(CR_ERROR, buf);
return false;
}
const char * hostname;
if(ndb_mgm_get_string_parameter(it, CFG_NODE_HOST, &hostname)){
BaseString::snprintf(buf, 255, "Unable to get hostname(%d) from config",CFG_NODE_HOST);
setError(CR_ERROR, buf);
return false;
}
const char * datadir;
if(!ndb_mgm_get_string_parameter(it, CFG_NODE_DATADIR, &datadir)){
NdbConfig_SetPath(datadir);
}
if (hostname && hostname[0] != 0 &&
!SocketServer::tryBind(0,hostname)) {
BaseString::snprintf(buf, 255, "Config hostname(%s) don't match a local interface,"
" tried to bind, error = %d - %s",
hostname, errno, strerror(errno));
setError(CR_ERROR, buf);
return false;
}
unsigned int _type;
if(ndb_mgm_get_int_parameter(it, CFG_TYPE_OF_SECTION, &_type)){
BaseString::snprintf(buf, 255, "Unable to get type of node(%d) from config",
CFG_TYPE_OF_SECTION);
setError(CR_ERROR, buf);
return false;
}
if(_type != m_node_type){
const char *type_s, *alias_s, *type_s2, *alias_s2;
alias_s= ndb_mgm_get_node_type_alias_string((enum ndb_mgm_node_type)m_node_type,
&type_s);
alias_s2= ndb_mgm_get_node_type_alias_string((enum ndb_mgm_node_type)_type,
&type_s2);
BaseString::snprintf(buf, 255, "This node type %s(%s) and config "
"node type %s(%s) don't match for nodeid %d",
alias_s, type_s, alias_s2, type_s2, nodeid);
setError(CR_ERROR, buf);
return false;
}
/**
* Check hostnames
*/
ndb_mgm_configuration_iterator iter(* conf, CFG_SECTION_CONNECTION);
for(iter.first(); iter.valid(); iter.next()){
Uint32 type = CONNECTION_TYPE_TCP + 1;
if(iter.get(CFG_TYPE_OF_SECTION, &type)) continue;
if(type != CONNECTION_TYPE_TCP) continue;
Uint32 nodeId1, nodeId2, remoteNodeId;
if(iter.get(CFG_CONNECTION_NODE_1, &nodeId1)) continue;
if(iter.get(CFG_CONNECTION_NODE_2, &nodeId2)) continue;
if(nodeId1 != nodeid && nodeId2 != nodeid) continue;
remoteNodeId = (nodeid == nodeId1 ? nodeId2 : nodeId1);
const char * name;
struct in_addr addr;
BaseString tmp;
if(!iter.get(CFG_CONNECTION_HOSTNAME_1, &name) && strlen(name)){
if(Ndb_getInAddr(&addr, name) != 0){
tmp.assfmt("Unable to lookup/illegal hostname %s, "
"connection from node %d to node %d",
name, nodeid, remoteNodeId);
setError(CR_ERROR, tmp.c_str());
return false;
}
}
if(!iter.get(CFG_CONNECTION_HOSTNAME_2, &name) && strlen(name)){
if(Ndb_getInAddr(&addr, name) != 0){
tmp.assfmt("Unable to lookup/illegal hostname %s, "
"connection from node %d to node %d",
name, nodeid, remoteNodeId);
setError(CR_ERROR, tmp.c_str());
return false;
}
}
}
return true;
}
static void
CHECK(const char* address, int expected_res, bool is_numeric= false)
{
struct in_addr addr;
char *addr_str1, *addr_str2;
char buf1[NDB_ADDR_STRLEN];
char buf2[NDB_ADDR_STRLEN];
fprintf(stderr, "Testing '%s'\n", address);
int res= Ndb_getInAddr(&addr, address);
if (res != expected_res)
{
fprintf(stderr, "> unexpected result: %d, expected: %d\n",
res, expected_res);
abort();
}
if (res != 0)
{
fprintf(stderr, "> returned -1, checking INADDR_NONE\n");
// Should return INADDR_NONE when when lookup fails
struct in_addr none;
none.s_addr = INADDR_NONE;
if (memcmp(&addr, &none, sizeof(none)) != 0)
{
addr_str1 = Ndb_inet_ntop(AF_INET,
static_cast<void*>(&addr),
buf1,
(socklen_t)sizeof(buf1));
addr_str2 = Ndb_inet_ntop(AF_INET,
static_cast<void*>(&none),
buf2,
(socklen_t)sizeof(buf2));
fprintf(stderr, "> didn't return INADDR_NONE after failure, "
"got: '%s', expected; '%s'\n", addr_str1, addr_str2);
abort();
}
fprintf(stderr, "> ok\n");
return;
}
addr_str1 = Ndb_inet_ntop(AF_INET,
static_cast<void*>(&addr),
buf1,
(socklen_t)sizeof(buf1));
fprintf(stderr, "> '%s' -> '%s'\n", address, addr_str1);
if (is_numeric)
{
// Check that numeric address always map back to itself
// ie. compare to value returned by 'inet_aton'
fprintf(stderr, "> Checking numeric address against inet_addr\n");
struct in_addr addr2;
addr2.s_addr = inet_addr(address);
addr_str2 = Ndb_inet_ntop(AF_INET,
static_cast<void*>(&addr2),
buf2,
(socklen_t)sizeof(buf2));
fprintf(stderr, "> inet_addr(%s) -> '%s'\n", address, addr_str2);
if (memcmp(&addr, &addr2, sizeof(struct in_addr)) != 0)
{
addr_str2 = Ndb_inet_ntop(AF_INET,
static_cast<void*>(&addr2),
buf2,
(socklen_t)sizeof(buf2));
fprintf(stderr, "> numeric address '%s' didn't map to same value as "
"inet_addr: '%s'", address, addr_str2);
abort();
}
fprintf(stderr, "> ok\n");
}
}
bool
ConfigRetriever::verifyConfig(const struct ndb_mgm_configuration * conf,
Uint32 nodeid)
{
char buf[255];
ndb_mgm_configuration_iterator it(* conf, CFG_SECTION_NODE);
if(it.find(CFG_NODE_ID, nodeid)){
BaseString::snprintf(buf, 255, "Unable to find node with id: %d", nodeid);
setError(CR_ERROR, buf);
return false;
}
const char * hostname;
if(it.get(CFG_NODE_HOST, &hostname)){
BaseString::snprintf(buf, 255, "Unable to get hostname(%d) from config",
CFG_NODE_HOST);
setError(CR_ERROR, buf);
return false;
}
if (hostname && hostname[0] != 0 &&
!SocketServer::tryBind(0,hostname)) {
BaseString::snprintf(buf, 255,
"The hostname this node should have according "
"to the configuration does not match a local "
"interface. Attempt to bind '%s' "
"failed with error: %d '%s'",
hostname, errno, strerror(errno));
setError(CR_ERROR, buf);
return false;
}
unsigned int _type;
if(it.get(CFG_TYPE_OF_SECTION, &_type)){
BaseString::snprintf(buf, 255, "Unable to get type of node(%d) from config",
CFG_TYPE_OF_SECTION);
setError(CR_ERROR, buf);
return false;
}
if(_type != (unsigned int)m_node_type){
const char *type_s, *alias_s, *type_s2, *alias_s2;
alias_s=
ndb_mgm_get_node_type_alias_string((enum ndb_mgm_node_type)m_node_type,
&type_s);
alias_s2=
ndb_mgm_get_node_type_alias_string((enum ndb_mgm_node_type)_type,
&type_s2);
BaseString::snprintf(buf, 255,
"This node type %s(%s) and config "
"node type %s(%s) don't match for nodeid %d",
alias_s, type_s, alias_s2, type_s2, nodeid);
setError(CR_ERROR, buf);
return false;
}
/**
* Check hostnames
*/
ndb_mgm_configuration_iterator iter(* conf, CFG_SECTION_CONNECTION);
for(iter.first(); iter.valid(); iter.next()){
Uint32 type = CONNECTION_TYPE_TCP + 1;
if(iter.get(CFG_TYPE_OF_SECTION, &type)) continue;
if(type != CONNECTION_TYPE_TCP) continue;
Uint32 nodeId1, nodeId2, remoteNodeId;
if(iter.get(CFG_CONNECTION_NODE_1, &nodeId1)) continue;
if(iter.get(CFG_CONNECTION_NODE_2, &nodeId2)) continue;
if(nodeId1 != nodeid && nodeId2 != nodeid) continue;
remoteNodeId = (nodeid == nodeId1 ? nodeId2 : nodeId1);
const char * name;
struct in_addr addr;
BaseString tmp;
if(!iter.get(CFG_CONNECTION_HOSTNAME_1, &name) && strlen(name)){
if(Ndb_getInAddr(&addr, name) != 0){
tmp.assfmt("Unable to lookup/illegal hostname %s, "
"connection from node %d to node %d",
name, nodeid, remoteNodeId);
setError(CR_ERROR, tmp.c_str());
return false;
}
}
if(!iter.get(CFG_CONNECTION_HOSTNAME_2, &name) && strlen(name)){
if(Ndb_getInAddr(&addr, name) != 0){
tmp.assfmt("Unable to lookup/illegal hostname %s, "
"connection from node %d to node %d",
name, nodeid, remoteNodeId);
setError(CR_ERROR, tmp.c_str());
return false;
}
}
}
return true;
}
