{

char myHostName[256];

gethostname(myHostName, sizeof(myHostName));

VSDOMParserErrorHandler errorHandler;

// Load the display device templates

VSDOMParser *configParser = new VSDOMParser;

errorHandler.resetErrors();

VSDOMDoc *config = configParser->ParseFile("/etc/vizstack/master_config.xml", errorHandler);

// Print out warning and error messages

vector<string> msgs;

errorHandler.getMessages (msgs);

for (unsigned int i = 0; i < msgs.size (); i++)

cout << msgs[i] << endl;

if(!config)

{

cerr << "ERROR: Unable to get the local configuration of this node." << endl;

return false;

}

VSDOMNode rootNode = config->getRootNode();

VSDOMNode systemNode = rootNode.getChildNode("system");

VSDOMNode systemTypeNode = systemNode.getChildNode("type");

string systemType = systemTypeNode.getValueAsString();

if(systemType=="standalone")

{

g_standalone = true;

g_hostName = "localhost";

}

else

{

VSDOMNode masterNode = systemNode.getChildNode("master");

if(masterNode.isEmpty())

{

cerr << "ERROR: Invalid configuration. You must specify a master." << endl;

return false;

}

g_ssmHost = masterNode.getValueAsString();

VSDOMNode masterPortNode = systemNode.getChildNode( "master_port");

if(masterPortNode.isEmpty())

{

cerr << "ERROR: Invalid configuration. You must specify a master port." << endl;

return false;

}

g_ssmPort = masterPortNode.getValueAsString();

if(g_ssmHost != "localhost")

{

int portNum = atoi(g_ssmPort.c_str());

char buffer[100];

sprintf(buffer, "%d",portNum);

if((portNum<=0) or (g_ssmPort != buffer))

{

cerr << "ERROR: Invalid configuration. Please check the master port you have specified (" << g_ssmPort << ") for errors." << endl;

return false;

}

}

else

if(g_ssmPort.size()>100) // prevent buffer overruns

{

cerr << "ERROR: Invalid configuration. The master port you have specified '%s' is too long (limit : 100 chars)." << endl;

return false;

}

g_standalone = false;

char myHostName[256];

if(gethostname(myHostName, sizeof(myHostName))<0)

{

perror("ERROR: Unable to get my hostname");

exit(-1);

}

if(g_ssmHost=="localhost")

g_hostName="localhost";

else

g_hostName = myHostName;

}

return true;

{

int nBytesWritten = 0;

const char *ptr = buf;

while(nBytesWritten != nBytes)

{

int ret = send(socket, ptr, nBytes - nBytesWritten, MSG_NOSIGNAL);

if(ret==-1)

{

if(errno==EINTR)

continue;

else

{

perror("Unable to write data to scoket");

return nBytesWritten;

}

}

else

{

nBytesWritten += ret;

ptr += ret;

}

}

return nBytesWritten;

{

int nBytesRead = 0;

char *ptr = buf;

while(nBytesRead != nBytes)

{

int ret = recv(socket, ptr, nBytes - nBytesRead, MSG_WAITALL);

if(ret==-1)

{

if(errno==EINTR)

continue;

else

{

return nBytesRead;

}

}

else

if(ret==0)

{

// EOF !

break;

}

else

{

nBytesRead += ret;

ptr += ret;

}

}

return nBytesRead;

{

char sizeStr[6];

// FIXME: can't handle messages larger than this due to the protocol limitations

// centralize the protocol limitations.

if(dataLen>99999)

{

fprintf(stderr,"Bad message length %d! May not exceed 99999!\n",dataLen);

return false;

}

sprintf(sizeStr,"%d", dataLen);

while(strlen(sizeStr)<5)

strcat(sizeStr, " ");

if(write_bytes(socket, sizeStr, 5)!=5)

{

fprintf(stderr,"Unable to write message header to scoket\n");

return false;

}

if(write_bytes(socket, data, dataLen)!=dataLen)

{

fprintf(stderr,"Unable to write message data to scoket\n");

return false;

}

return true;

{

// we do this by sending a query template message to the SSM

char message[1024];

sprintf(message,

"<ssm>\n"

" <get_templates>\n"

" <%s />\n"

" </get_templates>\n"

"</ssm>\n", templateType.c_str());

if(!write_message(ssmSocket, message, strlen(message)))

{

fprintf(stderr, "ERROR - unable to send the query message to SSM\n");

closeSocket(ssmSocket);

return false;

}

char *retmessage = 0;

if((retmessage = read_message(ssmSocket))==0)

{

fprintf(stderr, "ERROR - unable to receive X configuration\n");

closeSocket(ssmSocket);

return false;

}

VSDOMParserErrorHandler errorHandler;

VSDOMParser *configParser = 0;

configParser = new VSDOMParser;

errorHandler.resetErrors();

VSDOMDoc *config = configParser->ParseString(retmessage, errorHandler);

if(!config)

{

// Print out warning and error messages

vector<string> msgs;

errorHandler.getMessages (msgs);

for (unsigned int i = 0; i < msgs.size (); i++)

cout << msgs[i] << endl;

fprintf(stderr, "ERROR - bad return XML from SSM.\n");

fprintf(stderr, "Return XML was --\n");

fprintf(stderr, "----------------------------------------------\n");

fprintf(stderr, "%s", retmessage);

fprintf(stderr, "\n----------------------------------------------\n");

closeSocket(ssmSocket);

return false;

}

VSDOMNode rootNode = config->getRootNode();

VSDOMNode responseNode = rootNode.getChildNode( "response");

int status = responseNode.getChildNode("status").getValueAsInt();

if(status!=0)

{

string msg = responseNode.getChildNode("message").getValueAsString();

fprintf(stderr, "ERROR - Failure returned from SSM : %s\n", msg.c_str());

delete configParser;

return false;

}

VSDOMNode retValNode = responseNode.getChildNode("return_value");

nodes = retValNode.getChildNodes(templateType.c_str());

return true;

{

struct hostent* hp;

struct hostent ret;

char buffer[1000];

int h_errnop;

int ssmSocket = -1;

// If the master is on "localhost", then we use Unix Domain Sockets

if(ssmHost == "localhost")

{

ssmSocket = socket(AF_UNIX, SOCK_STREAM, 0);

if(ssmSocket < 0)

{

perror("ERROR - Unable to create a socket to communicate with the SSM");

return -1;

}

struct sockaddr_un sa;

sa.sun_family = AF_UNIX;

strcpy(sa.sun_path, ssmPort.c_str()); // on Linux, the path limit seems to be 118

if(connect(ssmSocket, (sockaddr*) &sa, sizeof(sa.sun_family)+sizeof(sa.sun_path))<0)

{

perror("ERROR - Unable to connect to the local SSM");

closeSocket(ssmSocket);

return -1;

}

}

else

{

// resolve the SSM host first

gethostbyname_r(ssmHost.c_str(), &ret, buffer, sizeof(buffer), &hp, &h_errnop);

if(!hp)

{

perror("ERROR - unable to resolve SSM hostname");

return -1;

}

ssmSocket = socket(AF_INET, SOCK_STREAM, 0);

if(ssmSocket < 0)

{

perror("ERROR - Unable to create a socket to communicate with the SSM");

return -1;

}

struct sockaddr_in si;

si.sin_family = AF_INET;

si.sin_port = htons(atoi(ssmPort.c_str()));

memcpy((void*)&si.sin_addr.s_addr, hp->h_addr, 4); // Copying an IPv4 address => 4 bytes

// Connect to the SSM

if(connect(ssmSocket, (sockaddr*) &si, sizeof(si))<0)

{

perror("ERROR - Unable to connect to the SSM");

closeSocket(ssmSocket);

return -1;

}

}

return ssmSocket;

{

shutdown(fd, SHUT_RDWR);

close(fd);

{

char *encodedCred = 0;

if(g_ssmHost == "localhost")

encodedCred = strdup(myIdentity.c_str());

else

{

// If the SSM is not on a local host, then it uses Munge to authenticate us.

// We need to send out a a munge encoded packet in the beginning

// so we need to call munge next, and use that to authenticate.

encodedCred = munge_encode(myIdentity.c_str());

if(!encodedCred)

{

fprintf(stderr,"ERROR - Unable to create a munge credential\n");

return false;

}

}

if(!write_message(ssmSocket, encodedCred, strlen(encodedCred)))

{

fprintf(stderr,"ERROR - Unable to send my identity to SSM\n");

free(encodedCred);

return false;

}

// Free the memory

free(encodedCred);

encodedCred = 0;

return true;