//singleInstance = CControllerThread::getInstance();

m_threadInfo.nThreadIndex = nThreadIndex;

struct timeval timeout;

int rc;

fd_set fd;

fd_set *writefd = NULL;

fd_set *readfd = NULL;

int dir;

timeout.tv_sec = 10;

timeout.tv_usec = 0;

FD_ZERO(&fd);

FD_SET(socket_fd, &fd);

dir = libssh2_session_block_directions(session);

if (dir & LIBSSH2_SESSION_BLOCK_INBOUND)

readfd = &fd;

if (dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)

writefd = &fd;

rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);

return rc;

CControllerThread *singleInstance;

singleInstance = CControllerThread::getInstance();

iterServerInfoMap iterMap;

typedef tbb::concurrent_vector<tapServerInfoMap> mapStore;

typedef mapStore::iterator iterMapVector;

mapStore mapStoreObj;

int whileserverCount = 0;

// CControllerThread *singleInstance;

// singleInstance = CControllerThread::getInstance();

unsigned long long int prevSizeroot = 0;

unsigned long long int currentSizeroot = 0;

unsigned long long int prevSizedolat = 0;

unsigned long long int currentSizedolat = 0;

vector <unsigned long long int> fileSize;

for(int i=0;i<10;i++)

fileSize.push_back(0);

char *hostAdress;

const char* userName;

const char* passWord;

char* dbUserName;

char* dbPassWord;

char* dbName;

char* dbPort;

char* lineType;

int globalCounter = 0;

int count = 0;

bool breakFlag;

char commandBuffer[1000];

char buffer[50];

char c[20];

int lProcessListIndex, lSpaceList;

FILE *p;

// char *lcPreferredAuthMethod[20];

int lineCounter;

DBConnection lDBConnectionObject;

while (1) {

count = 0;

breakFlag = false;

//print_micro_sec(1,stdout);

for (int i=(singleInstance->serverObject.size()/3);i<(singleInstance->serverObject.size()-singleInstance->serverObject.size()/3);i++)

{

if (IsThreadInShutdown()) {

breakFlag = true;

break;

}

tapServerInfoMap m_MapObject;

tagServerInfo &tsi = singleInstance->serverObject[i];

//if(tsi.bIsDirty == false)

//tsi.bIsDirty = true;

//else

//continue;

hostAdress = tsi.ipAdress;

cout <<"hostAdress2 ::: " << tsi.ipAdress <<endl;

userName = tsi.userName;

passWord = tsi.password;

dbUserName = tsi.dbUserName;

dbPassWord = tsi.dbPassword;

dbName = tsi.dbName;

dbPort = tsi.dbPort;

//cout <<"FilePath---" << tsi.Path[0].filePath << endl;

//FILE *fp = fopen("LineIds.txt","w+");

lineType = tsi.lineType;

globalCounter = 0;

if (!(tsi.dbconStatus)) {

if (0 == lDBConnectionObject.getQueryResult(m_MapObject, dbUserName, dbPassWord, dbName, dbPort, hostAdress, lineType)) {

// printf("db connection not found \n");

/* for (std::map <long,std::string>::iterator iterMap = m_MapObject.begin(); iterMap != m_MapObject.end(); iterMap++)

}

for (std::map <long,std::string>::iterator iterMap = m_MapObject.begin(); iterMap != m_MapObject.end(); iterMap++)

{

//cout << "userIds::" << iterMap->second << endl;

//cout << "first::" << iterMap->first << endl;

conn->orderIds.push_back(iterMap->first);

}

//std::cout<<"m_MapObject"<<m_MapObject.size()<<endl;

mapStoreObj.push_back(m_MapObject);

lDBConnectionObject.Close();

tsi.dbconStatus = true;

}

memset(buffer,'\0',sizeof(buffer));

commandBuffer[1000] = {0};

buffer[50] = {0};

c[20] = {0};

char *lpUserAuthList;

struct sockaddr_in sin;

int rc, sock, auth_pw = 0;

lProcessListIndex, lSpaceList = 1;

sprintf(buffer, "ping -c 3 %s | grep -c %s", tsi.ipAdress, "\"3 received\"");

p = popen(buffer, "r");

fgets(c, 10, p);

//cout << "ping Commmand buff" << buffer << endl;

//cout <<" C " << c << endl;

//pclose(p);

if (atoi(c) == 1) {

tsi.serverstatus = true;

} else {

usleep(1000);

p = popen(buffer,"r");

fgets(c,10,p);

pclose(p);

cout << "Else C" << c << endl;

if(atoi(c) == 1)

{

tsi.serverstatus = true;

}

else

{

tsi.serverstatus = false;

CcopyStructure::copyData(tsi,0,0,0);

continue;

}

}

rc = libssh2_init(0);

if (rc != 0) {

g_cSystemLogger.LogMessage("(%s:%s:%d)::failure establishing ssh", LOG_LOCATION);

return 1;

}

if (tsi.serverstatus == true && tsi.conectstatus == false) {

sock = socket(AF_INET, SOCK_STREAM, 0);

tsi.m_socketId = sock;

sin.sin_family = AF_INET;

sin.sin_port = htons(22);

sin.sin_addr.s_addr = inet_addr(tsi.ipAdress);

if (connect(sock, (struct sockaddr*) (&sin),

sizeof (struct sockaddr_in)) != 0) {

g_cSystemLogger.LogMessage("(%s:%s(:%d)::failure establishing ssh", LOG_LOCATION);

return -1;

}

session = libssh2_session_init();

if (libssh2_session_handshake(session, tsi.m_socketId)) {

return -1;

}

tsi.session = session;

lpUserAuthList = libssh2_userauth_list(session, userName, strlen(userName));

if (NULL == lpUserAuthList) {

g_cSystemLogger.LogMessage("(%s:%s(:%d):: get user auth list failed", LOG_LOCATION);

continue;

}

char lcPreferredAuthMethod[20] = "password";

g_cSystemLogger.LogMessage("(%s:%s(:%d)::authentication methods(%s)", LOG_LOCATION, lpUserAuthList);

if (strstr(lpUserAuthList, lcPreferredAuthMethod) != NULL) {

auth_pw |= 1;

g_cSystemLogger.LogMessage("(%s:%s(:%d)::authentication methods(%d)", LOG_LOCATION, auth_pw);

}

g_cSystemLogger.LogMessage("(%s:%s(:%d)::after auth_pw methods(%d)", LOG_LOCATION, auth_pw);

if (auth_pw & 1) {

if (libssh2_userauth_password(session, userName, passWord)) {

g_cSystemLogger.LogMessage("(%s:%s(:%d)::Authentation by password failed\n", LOG_LOCATION);

} else {

g_cSystemLogger.LogMessage("(%s:%s(:%d)::Authentation by password succeded\n", LOG_LOCATION);

}

}

tsi.session = session;

tsi.conectstatus = true;

}

tapServerInfoMap &MapObject = mapStoreObj.at(count++);

if (strcmp(tsi.lineType, "FO") == 0) {

lineCounter = 0;

for (iterMap = MapObject.begin(); iterMap != MapObject.end(); iterMap++) {

while (((channel = libssh2_channel_open_session(tsi.session)) == NULL) &&

(libssh2_session_last_error(tsi.session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN)) {

waitsocket(sock, tsi.session);

}

if (channel == NULL) {

g_cSystemLogger.LogMessage("(%s:%s(:%d))ssh channel opening fail",LOG_LOCATION);

// goto shutdown;

}

sprintf(commandBuffer, "%s %s%s%s%d%s%s%s", "/bin/netstat -n|/bin/grep -c", "\"", iterMap->second.c_str(), ":", 9602, ".*", "ESTABLISHED", "\"");

while ((rc = libssh2_channel_exec(channel, commandBuffer)) == LIBSSH2_ERROR_EAGAIN) {

waitsocket(sock, tsi.session);

}

int lnReturnCode;

lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer));

g_cSystemLogger.LogMessage("(%s:%s(:%d))::commandBuffer %s lnreturncode %d\n", LOG_LOCATION,commandBuffer,lnReturnCode);

//std::cout<<"iterMap->first" <<iterMap->first <<endl;

if (commandBuffer[0] == '1') {

strncpy(tsi.lineInfo[lineCounter].ipv4adresss, iterMap->second.c_str(), 16);

tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0';

tsi.lineInfo[lineCounter].status = TRUE;

tsi.lineInfo[lineCounter].userId = iterMap->first;

}

else if (commandBuffer[0] == '0') {

strncpy(tsi.lineInfo[lineCounter].ipv4adresss, iterMap->second.c_str(), 16);

tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0';

tsi.lineInfo[lineCounter].status = FALSE;

tsi.lineInfo[lineCounter].userId = iterMap->first;

}

//std::cout<<"tsi.lineInfo[lineCounter].userId" <<tsi.lineInfo[lineCounter].userId <<endl;

//std::cout<<"tsi.lineInfo[lineCounter].status" <<tsi.lineInfo[lineCounter].status <<endl;

if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) {

waitsocket(sock, tsi.session);

}

lineCounter++;

memset(commandBuffer, 0, sizeof (commandBuffer));

libssh2_channel_free(channel);

channel = NULL;

}

globalCounter = lineCounter;

}

/* if (strcmp(tsi.lineType, "CM") == 0) {

// for(int i=1;i<tsi.noOfFilePath;i++)

// {

// printf("Inside Filesizecheck \n");

// cout <<"filePath::::" << tsi.Path[0].filePath << endl;

if (!(strcmp(tsi.Path[0].filePath,"") == 0))

{

while (((channel = libssh2_channel_open_session(tsi.session)) == NULL) &&

(libssh2_session_last_error(tsi.session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN)) {

waitsocket(sock, tsi.session);

}

if (channel == NULL) {

g_cSystemLogger.LogMessage("(%s:%s(:%d))ssh channel opening fail",LOG_LOCATION);

// goto shutdown;

}

sprintf(commandBuffer,"%s %s %s", "du -b",tsi.Path[0].filePath,"| awk '{print $1}' ");

g_cSystemLogger.LogMessage("(%s:%s(:%d))::command for netstat %s\n", LOG_LOCATION, commandBuffer);

while ((rc = libssh2_channel_exec(channel, commandBuffer)) == LIBSSH2_ERROR_EAGAIN) {

waitsocket(sock, tsi.session);

}

size_t lnReturnCode;

lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer));

char buff[30];

int j=0;

int i=0;

while(commandBuffer[j]!='\n')

{

buff[i]=commandBuffer[j];

j++;

i++;

lnReturnCode--;

}

lnReturnCode--;

currentSizeroot = (atoi(buff));

if(lnReturnCode)

{

i=0;

j++;

memset(buff,0,sizeof(buff));

while(commandBuffer[j]!='\n')

{

buff[i]=commandBuffer[j];

j++;

i++;

lnReturnCode--;

}

}

currentSizedolat = (atoi(buff));

//cout <<"currentSizeroot" << currentSizeroot <<" "<<fileSize[0] <<endl;

//cout <<"currentSizedolat" << currentSizedolat <<" " <<fileSize[1] <<endl;

if(currentSizeroot!=currentSizedolat)

{

if((currentSizeroot-fileSize[0])>0 && (currentSizedolat-fileSize[1])>0)

{

tsi.Path[0].status=true;

}

else

{

tsi.Path[0].status=false;

}

fileSize.insert(fileSize.begin()+0,currentSizeroot);

fileSize.insert(fileSize.begin()+1,currentSizedolat);

}

else

{

if((currentSizeroot-fileSize[2])>0)

{

tsi.Path[0].status=true;

}

else

{

tsi.Path[0].status=false;

}

fileSize.insert(fileSize.begin()+2,currentSizeroot);

}

memset(commandBuffer, 0, sizeof (commandBuffer));

libssh2_channel_free(channel);

channel = NULL;

// }

}

/* std::cout<<"tsi.lineType"<<tsi.lineType<<endl;

for (lProcessListIndex = 1; lProcessListIndex < tsi.noOfProcess; lProcessListIndex++) {

g_cSystemLogger.LogMessage("(%s:%s(:%d))::process name\n", LOG_LOCATION);

while ((channel = libssh2_channel_open_session(tsi.session)) == NULL &&

libssh2_session_last_error(tsi.session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN) {

waitsocket(sock, tsi.session);

}

if (channel == NULL) {

fprintf(stderr, "failure establishing ssh");

//goto shutdown;

}

sprintf(commandBuffer, "%s %s", "pidof -s", tsi.processes[lProcessListIndex].name);

g_cSystemLogger.LogMessage("(%s:%s(:%d)):: Pid of process command %s\n", LOG_LOCATION, commandBuffer);

while ((rc = libssh2_channel_exec(channel, commandBuffer)) == LIBSSH2_ERROR_EAGAIN) {

waitsocket(sock, tsi.session);

}

size_t lnReturnCode;

lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer));

g_cSystemLogger.LogMessage("(%s:%s(:%d))::commandBuffer %s lnreturncode %d\n", LOG_LOCATION,commandBuffer,lnReturnCode);

if (lnReturnCode == 0) {

tsi.processes[lProcessListIndex].process_on_off = FALSE;

} else {

tsi.processes[lProcessListIndex].process_on_off = TRUE;

if (lnReturnCode != LIBSSH2_ERROR_EAGAIN) {

g_cSystemLogger.LogMessage("(%s:%s(:%d))::libbssh2 %d\n", LOG_LOCATION, lnReturnCode);

}

}

if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) {

waitsocket(sock, tsi.session);

}

g_cSystemLogger.LogMessage("(%s:%s(:%d))::tsi.processes[i].process_on_off %d \n", LOG_LOCATION, tsi.processes[lProcessListIndex].process_on_off);

memset(commandBuffer, 0, sizeof (commandBuffer));

if (channel) {

libssh2_channel_free(channel);

channel = NULL;

}

}

char percnt[5] = "\"%\"";

for (lSpaceList = 1; lSpaceList < tsi.noOfSpace; lSpaceList++) {

while ((channel = libssh2_channel_open_session(tsi.session)) == NULL &&

libssh2_session_last_error(tsi.session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN) {

waitsocket(sock, tsi.session);

}

if (channel == NULL) {

g_cSystemLogger.LogMessage("failure establishing ssh");

}

sprintf(commandBuffer, "%s %s %s %s %s", "df -hk | grep", tsi.space[lSpaceList].name, "| awk '{print $(NF-1)}' | awk -F", percnt, "'{print $1}'");

g_cSystemLogger.LogMessage("(%s:%s(:%d))::command for space%s\n", LOG_LOCATION, commandBuffer);

while ((rc = libssh2_channel_exec(channel, commandBuffer)) == LIBSSH2_ERROR_EAGAIN) {

waitsocket(sock, tsi.session);