int main(int argc, char *argv[]) { const char *hostname = "127.0.0.1"; const char *commandline = "uptime"; const char *username = "******"; const char *password = "******"; unsigned long hostaddr; int sock; struct sockaddr_in sin; const char *fingerprint; LIBSSH2_SESSION *session; LIBSSH2_CHANNEL *channel; int rc; int exitcode; char *exitsignal=(char *)"none"; int bytecount = 0; size_t len; LIBSSH2_KNOWNHOSTS *nh; int type; #ifdef WIN32 WSADATA wsadata; int err; err = WSAStartup(MAKEWORD(2,0), &wsadata); if (err != 0) { fprintf(stderr, "WSAStartup failed with error: %d\n", err); return 1; } #endif if (argc > 1) /* must be ip address only */ hostname = argv[1]; if (argc > 2) { username = argv[2]; } if (argc > 3) { password = argv[3]; } if (argc > 4) { commandline = argv[4]; } rc = libssh2_init (0); if (rc != 0) { fprintf (stderr, "libssh2 initialization failed (%d)\n", rc); return 1; } hostaddr = inet_addr(hostname); /* Ultra basic "connect to port 22 on localhost" * Your code is responsible for creating the socket establishing the * connection */ sock = socket(AF_INET, SOCK_STREAM, 0); sin.sin_family = AF_INET; sin.sin_port = htons(22); sin.sin_addr.s_addr = hostaddr; if (connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in)) != 0) { fprintf(stderr, "failed to connect!\n"); return -1; } /* Create a session instance */ session = libssh2_session_init(); if (!session) return -1; /* tell libssh2 we want it all done non-blocking */ libssh2_session_set_blocking(session, 0); /* ... start it up. This will trade welcome banners, exchange keys, * and setup crypto, compression, and MAC layers */ while ((rc = libssh2_session_handshake(session, sock)) == LIBSSH2_ERROR_EAGAIN); if (rc) { fprintf(stderr, "Failure establishing SSH session: %d\n", rc); return -1; } nh = libssh2_knownhost_init(session); if(!nh) { /* eeek, do cleanup here */ return 2; } /* read all hosts from here */ libssh2_knownhost_readfile(nh, "known_hosts", LIBSSH2_KNOWNHOST_FILE_OPENSSH); /* store all known hosts to here */ libssh2_knownhost_writefile(nh, "dumpfile", LIBSSH2_KNOWNHOST_FILE_OPENSSH); fingerprint = libssh2_session_hostkey(session, &len, &type); if(fingerprint) { struct libssh2_knownhost *host; #if LIBSSH2_VERSION_NUM >= 0x010206 /* introduced in 1.2.6 */ int check = libssh2_knownhost_checkp(nh, hostname, 22, fingerprint, len, LIBSSH2_KNOWNHOST_TYPE_PLAIN| LIBSSH2_KNOWNHOST_KEYENC_RAW, &host); #else /* 1.2.5 or older */ int check = libssh2_knownhost_check(nh, hostname, fingerprint, len, LIBSSH2_KNOWNHOST_TYPE_PLAIN| LIBSSH2_KNOWNHOST_KEYENC_RAW, &host); #endif fprintf(stderr, "Host check: %d, key: %s\n", check, (check <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)? host->key:"<none>"); /***** * At this point, we could verify that 'check' tells us the key is * fine or bail out. *****/ } else { /* eeek, do cleanup here */ return 3; } libssh2_knownhost_free(nh); if ( strlen(password) != 0 ) { /* We could authenticate via password */ while ((rc = libssh2_userauth_password(session, username, password)) == LIBSSH2_ERROR_EAGAIN); if (rc) { fprintf(stderr, "Authentication by password failed.\n"); goto shutdown; } } else { /* Or by public key */ while ((rc = libssh2_userauth_publickey_fromfile(session, username, "/home/user/" ".ssh/id_rsa.pub", "/home/user/" ".ssh/id_rsa", password)) == LIBSSH2_ERROR_EAGAIN); if (rc) { fprintf(stderr, "\tAuthentication by public key failed\n"); goto shutdown; } } #if 0 libssh2_trace(session, ~0 ); #endif /* Exec non-blocking on the remove host */ while( (channel = libssh2_channel_open_session(session)) == NULL && libssh2_session_last_error(session,NULL,NULL,0) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(sock, session); } if( channel == NULL ) { fprintf(stderr,"Error\n"); exit( 1 ); } while( (rc = libssh2_channel_exec(channel, commandline)) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(sock, session); } if( rc != 0 ) { fprintf(stderr,"Error\n"); exit( 1 ); } for( ;; ) { /* loop until we block */ int rc; do { char buffer[0x4000]; rc = libssh2_channel_read( channel, buffer, sizeof(buffer) ); if( rc > 0 ) { int i; bytecount += rc; fprintf(stderr, "We read:\n"); for( i=0; i < rc; ++i ) fputc( buffer[i], stderr); fprintf(stderr, "\n"); } else { if( rc != LIBSSH2_ERROR_EAGAIN ) /* no need to output this for the EAGAIN case */ fprintf(stderr, "libssh2_channel_read returned %d\n", rc); } } while( rc > 0 ); /* this is due to blocking that would occur otherwise so we loop on this condition */ if( rc == LIBSSH2_ERROR_EAGAIN ) { waitsocket(sock, session); } else break; } exitcode = 127; while( (rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN ) waitsocket(sock, session); if( rc == 0 ) { exitcode = libssh2_channel_get_exit_status( channel ); libssh2_channel_get_exit_signal(channel, &exitsignal, NULL, NULL, NULL, NULL, NULL); } if (exitsignal) fprintf(stderr, "\nGot signal: %s\n", exitsignal); else fprintf(stderr, "\nEXIT: %d bytecount: %d\n", exitcode, bytecount); libssh2_channel_free(channel); channel = NULL; shutdown: libssh2_session_disconnect(session, "Normal Shutdown, Thank you for playing"); libssh2_session_free(session); #ifdef WIN32 closesocket(sock); #else close(sock); #endif fprintf(stderr, "all done\n"); libssh2_exit(); return 0; }
void PJSSH::ExecuteCmd(const char* aCommand) const { if( !SessionIsOk ) { std::ostringstream o; o<<"Can not execute command since the SSH session is not set up ok. " "Last error message: "; throw std::logic_error(o.str()); } // Try to open a channel to be used for executing the command. LIBSSH2_CHANNEL* channel = libssh2_channel_open_session(mSession); if( NULL == channel ) { throw std::runtime_error("Could not open communication channel for " "executing remote command."); } // Execute the command. if( -1 == libssh2_channel_exec(channel,aCommand)) { throw std::runtime_error("Failed to execute the remote command."); } // Close the channel. libssh2_channel_close(channel); // Free resources. libssh2_channel_free(channel); }
bool RunCommand(const char *aCommand) { if (!mSessionOK) { return false; } LIBSSH2_CHANNEL *channel = libssh2_channel_open_session(mSession); if (channel == NULL) { strcpy(mErrorMessage, "Could not open SSH2 channel"); return false; } #ifdef libssh2_session_set_timeout libssh2_session_set_timeout(mTimeout); #endif if (libssh2_channel_exec(channel, aCommand) == -1) { strcpy(mErrorMessage, "Could not execute SSH2 command"); return false; } std::string response; char buf[1025]; ssize_t size = 1024; while (size == 1024) { size = libssh2_channel_read(channel, buf, 1024); buf[size] = '\0'; response += buf; } if (mResponse) { delete [] mResponse; } mResponse = new char[response.size()+1]; strcpy(mResponse, response.c_str()); libssh2_channel_close(channel); mExitCode = libssh2_channel_get_exit_status(channel); libssh2_channel_free(channel); return true; }
static int send_command(ssh_stream *s) { int error; git_buf request = GIT_BUF_INIT; error = gen_proto(&request, s->cmd, s->url); if (error < 0) goto cleanup; error = libssh2_channel_exec(s->channel, request.ptr); if (error < LIBSSH2_ERROR_NONE) { ssh_error(s->session, "SSH could not execute request"); goto cleanup; } s->sent_command = 1; cleanup: git_buf_free(&request); return error; }
int open_channel_and_exec(LIBSSH2_SESSION *session, int sock, const char *cmd, char **out) { int rc; LIBSSH2_CHANNEL *chan; chan = waitfor_open_channel(session, sock); if (!chan) return -1; while ((rc = libssh2_channel_exec(chan, cmd)) == LIBSSH2_ERROR_EAGAIN) waitsocket(session, sock); if (rc != 0) return -1; rc = read_channel(chan, session, sock, out); while ((rc = libssh2_channel_close(chan)) == LIBSSH2_ERROR_EAGAIN) waitsocket(session, sock); libssh2_channel_free(chan); return 0; }
int SSH2Channel::exec(const char *command, int timeout_ms, ExceptionSink *xsink) { AutoLocker al(parent->m); if (check_open(xsink)) return -1; BlockingHelper bh(parent); int rc; while (true) { rc = libssh2_channel_exec(channel, command); //printd(5, "SSH2Channel::exec() cmd=%s rc=%d\n", command, rc); if (rc == LIBSSH2_ERROR_EAGAIN) { if ((rc = parent->waitSocketUnlocked(xsink, SSH2CHANNEL_TIMEOUT, "SSH2CHANNEL-EXEC-ERROR", "SSH2Channel::exec", timeout_ms))) break; continue; } if (rc) parent->doSessionErrUnlocked(xsink); break; } return rc; }
static int send_command(ssh_stream *s) { int error; git_buf request = GIT_BUF_INIT; error = gen_proto(&request, s->cmd, s->url); if (error < 0) goto cleanup; error = libssh2_channel_exec( s->channel, request.ptr ); if (0 != error) goto cleanup; s->sent_command = 1; cleanup: git_buf_free(&request); return error; }
void CLibssh2::remotely_execute( const std::string& command, std::ostream& out, int* exitcode, std::string* exitsignal, std::string* errmsg, int* num_bytes) throw (utils::CException, sys::CSyscallException) { LIBSSH2_CHANNEL* channel = static_cast<LIBSSH2_CHANNEL*>(open_ssh_channel()); try { while (true) { int errcode = libssh2_channel_exec(channel, command.c_str()); if (0 == errcode) { break; } else if (errcode != LIBSSH2_ERROR_EAGAIN) { THROW_EXCEPTION(get_session_errmsg(), get_session_errcode()); } else { sys::CUtils::millisleep(10); } } *num_bytes = read_channel(channel, out); } catch (...) { *exitcode = close_ssh_channel(channel, exitsignal, errmsg); throw; } // 不能放在try{}中, // 否则可能会触发递归调用close_channel(),原因是close_channel()也抛异常 *exitcode = close_ssh_channel(channel, exitsignal, errmsg); }
int exec_one_cmd(char* cmd, LIBSSH2_SESSION *session, LIBSSH2_CHANNEL **channel, int sock) { int rc; //while((*channel = libssh2_channel_open_session(session)) == NULL && libssh2_session_last_error(session,NULL,NULL,0) == LIBSSH2_ERROR_EAGAIN ) waitsocket(sock, session); *channel = libssh2_channel_open_session(session); if( *channel == NULL ) { fprintf(stderr,"Error\n"); exit(1); } // while((rc = libssh2_channel_exec(*channel, cmd)) == LIBSSH2_ERROR_EAGAIN ) waitsocket(sock, session); rc = libssh2_channel_exec(*channel, cmd); if(rc!=0) { fprintf(stderr,"Error\n"); exit(1); } read_channel(session, *channel, sock); // while((rc = libssh2_channel_close(*channel)) == LIBSSH2_ERROR_EAGAIN) waitsocket(sock, session); rc = libssh2_channel_close(*channel); return rc; }
int ssh_exec(ssh_conn_t *conn, param_t *params) { LIBSSH2_CHANNEL *channel; int rc; int exitcode = 127; char *exitsignal=(char *)"none"; const char *commandline = params->command; /* Exec non-blocking on the remove host */ while( (channel = libssh2_channel_open_session(conn->session)) == NULL && libssh2_session_last_error(conn->session,NULL,NULL,0) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(conn); } if( channel == NULL ) { fprintf(stderr,"Error\n"); return ( 1 ); } rc = ssh_setenv(channel, params); if(rc<0) { if(rc==LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED) printf("Error: Environment variable is not accepted by target SSH server."); goto shutdown; } while( (rc = libssh2_channel_exec(channel, commandline)) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(conn); } if( rc != 0 ) { fprintf(stderr,"Error\n"); return ( 1 ); } int stream_id = 0; for( ;; ) { /* loop until we block */ int rc; do { char buffer[0x4000]; rc = libssh2_channel_read_ex( channel, stream_id, buffer, sizeof(buffer) ); if( rc > 0 ) { fwrite(buffer, sizeof(char), rc, stream_id==0?stdout:stderr); }else{ if( rc != LIBSSH2_ERROR_EAGAIN ) goto shutdown; } } while( rc > 0 ); /* this is due to blocking that would occur otherwise so we loop on this condition */ if( rc == LIBSSH2_ERROR_EAGAIN ) { waitsocket(conn); } else break; stream_id = stream_id==0?1:0; } while( (rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN ) waitsocket(conn); if( rc == 0 ) { exitcode = libssh2_channel_get_exit_status( channel ); libssh2_channel_get_exit_signal(channel, &exitsignal, NULL, NULL, NULL, NULL, NULL); } shutdown: libssh2_channel_free(channel); channel = NULL; return exitcode; }
void* ssh_client_thread(void* data) { guac_client* client = (guac_client*) data; guac_ssh_client* ssh_client = (guac_ssh_client*) client->data; guac_ssh_settings* settings = ssh_client->settings; char buffer[8192]; pthread_t input_thread; /* Init SSH base libraries */ if (guac_common_ssh_init(client)) { guac_client_abort(client, GUAC_PROTOCOL_STATUS_SERVER_ERROR, "SSH library initialization failed"); return NULL; } /* Set up screen recording, if requested */ if (settings->recording_path != NULL) { guac_common_recording_create(client, settings->recording_path, settings->recording_name, settings->create_recording_path); } /* Create terminal */ ssh_client->term = guac_terminal_create(client, settings->font_name, settings->font_size, settings->resolution, settings->width, settings->height, settings->color_scheme); /* Fail if terminal init failed */ if (ssh_client->term == NULL) { guac_client_abort(client, GUAC_PROTOCOL_STATUS_SERVER_ERROR, "Terminal initialization failed"); return NULL; } /* Set up typescript, if requested */ if (settings->typescript_path != NULL) { guac_terminal_create_typescript(ssh_client->term, settings->typescript_path, settings->typescript_name, settings->create_typescript_path); } /* Get user and credentials */ ssh_client->user = guac_ssh_get_user(client); /* Open SSH session */ ssh_client->session = guac_common_ssh_create_session(client, settings->hostname, settings->port, ssh_client->user); if (ssh_client->session == NULL) { /* Already aborted within guac_common_ssh_create_session() */ return NULL; } pthread_mutex_init(&ssh_client->term_channel_lock, NULL); /* Open channel for terminal */ ssh_client->term_channel = libssh2_channel_open_session(ssh_client->session->session); if (ssh_client->term_channel == NULL) { guac_client_abort(client, GUAC_PROTOCOL_STATUS_UPSTREAM_ERROR, "Unable to open terminal channel."); return NULL; } #ifdef ENABLE_SSH_AGENT /* Start SSH agent forwarding, if enabled */ if (ssh_client->enable_agent) { libssh2_session_callback_set(ssh_client->session, LIBSSH2_CALLBACK_AUTH_AGENT, (void*) ssh_auth_agent_callback); /* Request agent forwarding */ if (libssh2_channel_request_auth_agent(ssh_client->term_channel)) guac_client_log(client, GUAC_LOG_ERROR, "Agent forwarding request failed"); else guac_client_log(client, GUAC_LOG_INFO, "Agent forwarding enabled."); } ssh_client->auth_agent = NULL; #endif /* Start SFTP session as well, if enabled */ if (settings->enable_sftp) { /* Create SSH session specific for SFTP */ guac_client_log(client, GUAC_LOG_DEBUG, "Reconnecting for SFTP..."); ssh_client->sftp_session = guac_common_ssh_create_session(client, settings->hostname, settings->port, ssh_client->user); if (ssh_client->sftp_session == NULL) { /* Already aborted within guac_common_ssh_create_session() */ return NULL; } /* Request SFTP */ ssh_client->sftp_filesystem = guac_common_ssh_create_sftp_filesystem( ssh_client->sftp_session, "/"); /* Expose filesystem to connection owner */ guac_client_for_owner(client, guac_common_ssh_expose_sftp_filesystem, ssh_client->sftp_filesystem); /* Init handlers for Guacamole-specific console codes */ ssh_client->term->upload_path_handler = guac_sftp_set_upload_path; ssh_client->term->file_download_handler = guac_sftp_download_file; guac_client_log(client, GUAC_LOG_DEBUG, "SFTP session initialized"); } /* Request PTY */ if (libssh2_channel_request_pty_ex(ssh_client->term_channel, "linux", sizeof("linux")-1, NULL, 0, ssh_client->term->term_width, ssh_client->term->term_height, 0, 0)) { guac_client_abort(client, GUAC_PROTOCOL_STATUS_UPSTREAM_ERROR, "Unable to allocate PTY."); return NULL; } /* If a command is specified, run that instead of a shell */ if (settings->command != NULL) { if (libssh2_channel_exec(ssh_client->term_channel, settings->command)) { guac_client_abort(client, GUAC_PROTOCOL_STATUS_UPSTREAM_ERROR, "Unable to execute command."); return NULL; } } /* Otherwise, request a shell */ else if (libssh2_channel_shell(ssh_client->term_channel)) { guac_client_abort(client, GUAC_PROTOCOL_STATUS_UPSTREAM_ERROR, "Unable to associate shell with PTY."); return NULL; } /* Logged in */ guac_client_log(client, GUAC_LOG_INFO, "SSH connection successful."); /* Start input thread */ if (pthread_create(&(input_thread), NULL, ssh_input_thread, (void*) client)) { guac_client_abort(client, GUAC_PROTOCOL_STATUS_SERVER_ERROR, "Unable to start input thread"); return NULL; } /* Set non-blocking */ libssh2_session_set_blocking(ssh_client->session->session, 0); /* While data available, write to terminal */ int bytes_read = 0; for (;;) { /* Track total amount of data read */ int total_read = 0; pthread_mutex_lock(&(ssh_client->term_channel_lock)); /* Stop reading at EOF */ if (libssh2_channel_eof(ssh_client->term_channel)) { pthread_mutex_unlock(&(ssh_client->term_channel_lock)); break; } /* Read terminal data */ bytes_read = libssh2_channel_read(ssh_client->term_channel, buffer, sizeof(buffer)); pthread_mutex_unlock(&(ssh_client->term_channel_lock)); /* Attempt to write data received. Exit on failure. */ if (bytes_read > 0) { int written = guac_terminal_write_stdout(ssh_client->term, buffer, bytes_read); if (written < 0) break; total_read += bytes_read; } else if (bytes_read < 0 && bytes_read != LIBSSH2_ERROR_EAGAIN) break; #ifdef ENABLE_SSH_AGENT /* If agent open, handle any agent packets */ if (ssh_client->auth_agent != NULL) { bytes_read = ssh_auth_agent_read(ssh_client->auth_agent); if (bytes_read > 0) total_read += bytes_read; else if (bytes_read < 0 && bytes_read != LIBSSH2_ERROR_EAGAIN) ssh_client->auth_agent = NULL; } #endif /* Wait for more data if reads turn up empty */ if (total_read == 0) { fd_set fds; struct timeval timeout; FD_ZERO(&fds); FD_SET(ssh_client->session->fd, &fds); /* Wait for one second */ timeout.tv_sec = 1; timeout.tv_usec = 0; if (select(ssh_client->session->fd + 1, &fds, NULL, NULL, &timeout) < 0) break; } } /* Kill client and Wait for input thread to die */ guac_client_stop(client); pthread_join(input_thread, NULL); pthread_mutex_destroy(&ssh_client->term_channel_lock); guac_client_log(client, GUAC_LOG_INFO, "SSH connection ended."); return NULL; }
RET_CODE serverConnectThread::Process(void* pcThreadParam) { 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=0;i<(singleInstance->serverObject.size()/3);i++) { lineCounter =0; 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 <<"hostAdress1 ::: " << 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++) { fprintf(fp,"\n"); fprintf(fp,"%ld",(*iterMap).first); }*/ } 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\""); g_cSystemLogger.LogMessage("(%s:%s:%d)::Ping Buffer %s", LOG_LOCATION,buffer); p = popen(buffer, "r"); fgets(c, 10, p); //cout << "ping Commmand buff" << buffer << endl; // cout <<" C " << c << endl; //pclose(p); g_cSystemLogger.LogMessage("(%s:%s:%d)::If Ping Output %s", LOG_LOCATION,c); if (atoi(c) == 1) { tsi.serverstatus = true; } else { usleep(1000); p = popen(buffer,"r"); fgets(c,10,p); pclose(p); g_cSystemLogger.LogMessage("(%s:%s:%d)::Else Ping Output %s", LOG_LOCATION,c); cout << "Else C" << c << endl; if(atoi(c) == 1) { tsi.serverstatus = true; } else { tsi.serverstatus = false; CcopyStructure::copyData(tsi,0,0,0); continue; } } memset(buffer,'\0',sizeof(buffer)); memset(c,'\0',sizeof(c)); 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) { int i=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[i].ipv4adresss, iterMap->second.c_str(), 16); tsi.lineInfo[i].ipv4adresss[16] = '\0'; tsi.lineInfo[i].status = TRUE; tsi.lineInfo[i].userId = iterMap->first; } else if (commandBuffer[0] == '0') { strncpy(tsi.lineInfo[i].ipv4adresss, iterMap->second.c_str(), 16); tsi.lineInfo[i].ipv4adresss[16] = '\0'; tsi.lineInfo[i].status = FALSE; tsi.lineInfo[i].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); } i++; memset(commandBuffer, 0, sizeof (commandBuffer)); libssh2_channel_free(channel); channel = NULL; } //globalCounter = lineCounter; } /* if (strcmp(tsi.lineType, "CM") == 0) { int 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(), ":", 9601, ".*", "ESTABLISHED", "\""); 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); } int lnReturnCode; lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer)); 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; } if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) { waitsocket(sock, tsi.session); } lineCounter++; memset(commandBuffer, 0, sizeof (commandBuffer)); libssh2_channel_free(channel);elOrderI channel = NULL; } globalCounter = lineCounter; } */ // 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; if (strcmp(tsi.lineType, "ColoBridge") == 0) { singleInstance g_cSystemLogger.LogMessage("(%s:%s(:%d))::Inside ColoBridge \n", LOG_LOCATION); memset(tsi.lineType, 0, sizeof (tsi.lineType)); strcpy(tsi.lineType,"CM"); std::cout<<"LineType"<<tsi.lineType<<endl; int lineCounter = 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%s%d%s%s%s", "/bin/netstat -n|/bin/grep -c", "\"", "192.168.30.32", ":", 2004, ".*", "ESTABLISHED", "\""); 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); } int lnReturnCode; lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer)); if (commandBuffer[0] == '1') { tsi.lineInfo[lineCounter].userId=2004; strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.32", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=2004; tsi.lineInfo[lineCounter].status = TRUE; } else if (commandBuffer[0] == '0') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.32", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=2004; tsi.lineInfo[lineCounter].status = FALSE; } if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) { waitsocket(sock, tsi.session); } lineCounter++; memset(commandBuffer, 0, sizeof (commandBuffer)); libssh2_channel_free(channel); channel = NULL; 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", "\"", "192.168.30.32", ":", 2005, ".*", "ESTABLISHED", "\""); 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); } lnReturnCode; lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer)); if (commandBuffer[0] == '1') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.32", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=2005; tsi.lineInfo[lineCounter].status = TRUE; } else if (commandBuffer[0] == '0') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.32", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=2005; tsi.lineInfo[lineCounter].status = FALSE; } if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) { waitsocket(sock, tsi.session); } lineCounter++; memset(commandBuffer, 0, sizeof (commandBuffer)); libssh2_channel_free(channel); channel = NULL; singleInstance->serverObject.size() 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", "\"", "192.168.30.32", ":", 5432, ".*", "ESTABLISHED", "\""); 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); } lnReturnCode; lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer)); if (commandBuffer[0] == '2') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.32", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=5432; tsi.lineInfo[lineCounter].status = TRUE; } else if (commandBuffer[0] == '0') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.32", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=5432; tsi.lineInfo[lineCounter].status = FALSE; } if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) { waitsocket(sock, tsi.session); } lineCounter++; memset(commandBuffer, 0, sizeof (commandBuffer)); libssh2_channel_free(channel); channel = NULL; 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", "\"", "192.168.30.231", ":", 2004, ".*", "ESTABLISHED", "\""); singleInstance->serverObject.size() 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); } lnReturnCode; lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer)); if (commandBuffer[0] == '1') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.231", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=2004; tsi.lineInfo[lineCounter].status = TRUE; } else if (commandBuffer[0] == '0') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.231", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=2004; tsi.lineInfo[lineCounter].status = FALSE; } if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) { waitsocket(sock, tsi.session); } lineCounter++; memset(commandBuffer, 0, sizeof (commandBuffer)); libssh2_channel_free(channel); channel = NULL; 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", "\"", "192.168.30.231", ":", 2005, ".*", "ESTABLISHED", "\""); 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); } lnReturnCode; lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer)); if (commandBuffer[0] == '1') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.231", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=2005; tsi.lineInfo[lineCounter].status = TRUE; } else if (commandBuffer[0] == '0') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.231", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=2005; tsi.lineInfo[lineCounter].status = FALSE; } if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) { waitsocket(sock, tsi.session); } lineCounter++; memset(commandBuffer, 0, sizeof (commandBuffer)); libssh2_channel_free(channel); channel = NULL; 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", "\"", "192.168.30.231", ":", 5432, ".*", "ESTABLISHED", "\""); 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); } lnReturnCode; lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer)); //std::cout<<"lnReturnCode"<<lnReturnCode<<endl; if (commandBuffer[0] == '2') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.231", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=5432; tsi.lineInfo[lineCounter].status = TRUE; } else if (commandBuffer[0] == '0') { strncpy(tsi.lineInfo[lineCounter].ipv4adresss, "192.168.30.231", 16); tsi.lineInfo[lineCounter].ipv4adresss[16] = '\0'; tsi.lineInfo[lineCounter].userId=5432; tsi.lineInfo[lineCounter].status = FALSE; } if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) { waitsocket(sock, tsi.session); } lineCounter++; memset(commandBuffer, 0, sizeof (commandBuffer)); libssh2_channel_free(channel); channel = NULL; globalCounter = lineCounter; }*/ 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); } int lnReturnCode; lnReturnCode = libssh2_channel_read(channel, commandBuffer, sizeof (commandBuffer)); if (lnReturnCode >= 0) { if (atoi(commandBuffer) > 90) { tsi.space[lSpaceList].space_full = TRUE; } else { tsi.space[lSpaceList].space_full = FALSE; } } if (LIBSSH2_ERROR_EAGAIN == lnReturnCode) { waitsocket(sock, tsi.session); } memset(commandBuffer, 0, sizeof (commandBuffer)); if (channel) { libssh2_channel_free(channel); channel = NULL; } } CcopyStructure::copyData(tsi, tsi.noOfProcess, tsi.noOfSpace, tsi.noOfLine); } // whileserverCount++; //std::cout << "while count" << whileserverCount << endl; ///if(!(singleInstance->is_connected(singleInstance->socketId))) //singleInstance->makeSocketConnection(); if (breakFlag) { break; } } for (int i=0;i<(singleInstance->serverObject.size()/3);i++) { tagServerInfo tsi; tsi = (singleInstance->serverObject[i]); libssh2_session_disconnect(tsi.session, "Shutting down,thank you"); libssh2_session_free(tsi.session); close(tsi.m_socketId); libssh2_exit(); } return 1; }
bool StartLineProcessCollector::collect(MONITORING::leaseProcessStart *sample, StartLineProcessConnector *conn) { if (NULL == sample) { g_cSystemLogger.LogMessage("(%s:%s:%d):: sample is NULL \n \n ", LOG_LOCATION); return false; } int i=0; ItrServerDetails serIter; lineDetails ld; g_cSystemLogger.LogMessage("(%s:%s:%d)::cancelid %d \n ", LOG_LOCATION,sample->ip_info[i].CancelOrderId); if(sample->ip_info[i].CancelOrderId!=0) { char buf[50]={0}; char recvbuf[512]={0}; int recvLen; g_cSystemLogger.LogMessage("(%s:%s:%d):: size of order vector %d \n ",LOG_LOCATION,conn->orderIds.size()); for(i=0;i<conn->orderIds.size();i++) { //g_cSystemLogger.LogMessage("(%s:%s(:%d)::Inside CancelOrder %d \n", LOG_LOCATION,sample->ip_info[i].CancelOrderId); int pos; int j; pos+=sprintf(buf+5,"%s%d%s","#",conn->orderIds[i],"#"); g_cSystemLogger.LogMessage("(%s:%s(:%d)::order length %d buf %s \n", LOG_LOCATION,pos,buf); char c='0'; for(j=0;j<=3;j++) { buf[j]=c; //g_cSystemLogger.LogMessage("(%s:%s(:%d)::Inside CancelOrder buf %c \n", LOG_LOCATION,buf[j]); } char p=(char)(((int)'0')+pos); buf[j]=p; g_cSystemLogger.LogMessage("(%s:%s(:%d)::Inside CancelOrder buf %s socketId %d \n", LOG_LOCATION,buf,CControllerThread::getInstance()->socketId); if(recvLen==write(CControllerThread::getInstance()->socketId,buf,sizeof(buf))) { g_cSystemLogger.LogMessage("(%s:%s(:%d)::writeLen %d \n", LOG_LOCATION,recvLen); //CControllerThread::getInstance()->makeSocketConnection(); } g_cSystemLogger.LogMessage("(%s:%s(:%d)::write sucessfull writeLen %d \n", LOG_LOCATION,recvLen); if(recvLen=recv(CControllerThread::getInstance()->socketId,recvbuf,sizeof(recvbuf),0)<0) { g_cSystemLogger.LogMessage("(%s:%s(:%d)::Recv Error \n", LOG_LOCATION); } g_cSystemLogger.LogMessage("(%s:%s(:%d)::RecvLen %d recvbuf %s \n", LOG_LOCATION,recvLen,recvbuf); strncpy(ld.CancelOrderStatus,recvbuf,sizeof(recvbuf)); CcopyStructure::copyCommandData(ld, ld.line_count); memset(buf,0,sizeof(buf)); pos=0; sleep(1); } return true; } else { for(i=0;i<sample->ip_info.length();i++) { if(strcmp(sample->ip_info[i].ipadress,"")==0) break; LIBSSH2_CHANNEL *channel2; LIBSSH2_SESSION *session; char* userName; char* passWord; struct sockaddr_in sin; int rc, sock, auth_pw = 0; char *exitsignal = (char *) "none"; size_t lnReturnCode; char command[12324] = {0}; char processes[8024] = {0}; char *lpUserAuthList; g_cSystemLogger.LogMessage("(%s:%s:%d):: Debug", LOG_LOCATION); rc = libssh2_init(0); strcpy(ld.ipadress,sample->ip_info[i].ipadress); g_cSystemLogger.LogMessage("(%s:%s:%d)::Sequence Length %d ipadress %s,and psl %s cancelOrderId %d value of i %d \n", LOG_LOCATION, sample->ip_info._length,sample->ip_info[i].ipadress,sample->ip_info[i].psl,sample->ip_info[i].CancelOrderId,i); sock = socket(AF_INET, SOCK_STREAM, 0); sin.sin_family = AF_INET; sin.sin_port = htons(22); sin.sin_addr.s_addr = inet_addr(sample->ip_info[i].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, sock)) { g_cSystemLogger.LogMessage("(%s:%s(:%d):: failure ssh session initiation", LOG_LOCATION); } /* if((strcmp(sample->ip_info[i].ipadress,"192.168.30.32")==0)|| (strcmp(sample->ip_info[i].psl,"192.168.30.231")==0)) { userName = "******"; passWord = "******"; } else*/ userName = "******"; passWord = "******"; lpUserAuthList = libssh2_userauth_list(session, userName, strlen(userName)); if (NULL == lpUserAuthList) { g_cSystemLogger.LogMessage("(%s:%s(:%d):: get user auth list failed", LOG_LOCATION); } 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); } 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 mint succesded\n", LOG_LOCATION); } } while ((channel2 = libssh2_channel_open_session(session)) == NULL && libssh2_session_last_error(session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock, session); } if (channel2 == NULL) { g_cSystemLogger.LogMessage("(%s:%s(:%d))ssh channel opening fail", LOG_LOCATION); } if(strcmp(sample->ip_info[i].psl,"Process")==0) { g_cSystemLogger.LogMessage("(%s:%s(:%d)) Inside Process", LOG_LOCATION); for(serIter=conn->getServerInfo().begin();serIter!=conn->getServerInfo().end();serIter++) { g_cSystemLogger.LogMessage("(%s:%s(:%d)) ipadress from iter %s", LOG_LOCATION,serIter->ipAdress); tagServerInfo &tagServ = *serIter; g_cSystemLogger.LogMessage("(%s:%s(:%d)) ipadress from tagserver %s sampeip %s \n", LOG_LOCATION,tagServ.ipAdress,sample->ip_info[i].ipadress); if(strcmp(tagServ.ipAdress,sample->ip_info[i].ipadress)==0) { int pos=0; g_cSystemLogger.LogMessage("(%s:%s(:%d)) tagServ %s sample %s processLen %d \n", LOG_LOCATION,tagServ.ipAdress,sample->ip_info[i].ipadress,tagServ.noOfProcess); for(int j=1;j<tagServ.noOfProcess;j++) { g_cSystemLogger.LogMessage("(%s:%s(:%d)) Process %s \n", LOG_LOCATION,tagServ.processes[j].name); if(j==(tagServ.noOfProcess-1)) { sprintf(processes+pos,tagServ.processes[j].name); } else { pos+=sprintf(processes+pos,"%s%s",tagServ.processes[j].name,"|"); } } sprintf(command,"%s %s%s%s%s %s%s%s%s","ps -ef | egrep -v ","\"", "egrep|vi|tail|cat|emacs|more|nohup","\"" ,"| egrep","\"",processes,"\"","| grep -v daemon"); g_cSystemLogger.LogMessage("(%s:%s(:%d)) command %s", LOG_LOCATION,command); while ((rc = libssh2_channel_exec(channel2, command)) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock, session); } lnReturnCode = libssh2_channel_read(channel2, command, sizeof (command)); g_cSystemLogger.LogMessage("(%s:%s(:%d)) lnReturnCode %d command %s", LOG_LOCATION,lnReturnCode,command); strncpy(ld.processInfo,command,sizeof(command)); memset(command, 0, sizeof (command)); libssh2_channel_free(channel2); channel2 = NULL; } } } else if((strcmp(sample->ip_info[i].psl,"Space"))==0) { while ((rc = libssh2_channel_exec(channel2, "df -kh |grep -v grep")) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock, session); } lnReturnCode = libssh2_channel_read(channel2, command, sizeof (command)); g_cSystemLogger.LogMessage("(%s:%s(:%d)lnReturnCode %d command after executing %s\n", LOG_LOCATION, lnReturnCode, command); strcpy(ld.spaceInfo,command); memset(command, 0, sizeof (command)); libssh2_channel_free(channel2); channel2 = NULL; } else if((strcmp(sample->ip_info[i].psl,"Line"))==0) { DBConnection lDBConnectionObject; char* dbUserName = "******"; char* dbPassWord = "******"; char* dbName = "mani"; char* dbPort = "5432"; if(0==lDBConnectionObject.getFoPiQueryResult(dbUserName,dbPassWord,dbName,dbPort,sample->ip_info[i].ipadress,ld)) { g_cSystemLogger.LogMessage("(%s:%s(:%d) Failed DB query \n", LOG_LOCATION); } g_cSystemLogger.LogMessage("(%s:%s(:%d) LineId %d Product details %s line count %d\n", LOG_LOCATION,ld.ld[0].fo_id,ld.ld[0].product_details,ld.line_count); lDBConnectionObject.Close(); } iterMap = conn->getPath().find(sample->ip_info[i].ipadress); g_cSystemLogger.LogMessage("(%s:%s(:%d))Path %s \n", LOG_LOCATION,iterMap->second.c_str()); if (sample->ip_info[i].status == true) { sprintf(command, "%s%s",iterMap->second.c_str(),"/clear_server.sh >> /tmp/LOGS/cronlog 2>&1 &"); while ((rc = libssh2_channel_exec(channel2, command)) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock, session); } lnReturnCode = libssh2_channel_read(channel2, command, sizeof (command)); g_cSystemLogger.LogMessage("(%s:%s(:%d)lnReturnCode %d command after executing %s\n", LOG_LOCATION, lnReturnCode, command); memset(command, 0, sizeof (command)); libssh2_channel_free(channel2); channel2 = NULL; } else if((sample->ip_info[i].status==false) && ((strcmp(sample->ip_info[i].psl,""))==0) && (sample->ip_info[i].CancelOrderId==0)) { sprintf(command, "%s", "cd /home/mint/ga/bin; nohup ./shutdownall.sh >> /tmp/LOGS/cronlog1 2>&1 &"); g_cSystemLogger.LogMessage("(%s:%s(:%d)%s\n", LOG_LOCATION, command); while ((rc = libssh2_channel_exec(channel2, command)) == LIBSSH2_ERROR_EAGAIN) { g_cSystemLogger.LogMessage("(%s:%s(:%d) ERROR Running command %d\n", LOG_LOCATION, rc); waitsocket(sock, session); } size_t lnReturnCode; lnReturnCode = libssh2_channel_read(channel2, command, sizeof (command)); g_cSystemLogger.LogMessage("(%s:%s(:%d)lnReturnCode %d commandBuffer %s\n", LOG_LOCATION, lnReturnCode, command); memset(command, 0, sizeof (command)); libssh2_channel_free(channel2); channel2 = NULL; } g_cSystemLogger.LogMessage("(%s:%s(:%d)space %s\n", LOG_LOCATION,ld.spaceInfo); CcopyStructure::copyCommandData(ld, ld.line_count); } } return true; }
int oph_ssh_submit(const char *cmd) { int sock; struct sockaddr_in sin; struct addrinfo hints, *result; LIBSSH2_SESSION *session; LIBSSH2_CHANNEL *channel; int rc; int exitcode; char *exitsignal = (char *) "none"; int bytecount = 0; memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = 0; hints.ai_protocol = 0; result = NULL; rc = getaddrinfo(oph_ip_target_host, NULL, &hints, &result); if (rc != 0) { pmesg_safe(&global_flag, LOG_ERROR, __FILE__, __LINE__, "Unable to resolve address from target hostname: %s\n", gai_strerror(rc)); return OPH_LIBSSH_ERROR; } sock = socket(AF_INET, SOCK_STREAM, 0); sin.sin_family = AF_INET; sin.sin_port = htons(22); sin.sin_addr.s_addr = ((struct sockaddr_in *) result->ai_addr)->sin_addr.s_addr; freeaddrinfo(result); if (connect(sock, (struct sockaddr *) (&sin), sizeof(struct sockaddr_in)) != 0) { #ifdef WIN32 closesocket(sock); #else close(sock); #endif pmesg_safe(&global_flag, LOG_ERROR, __FILE__, __LINE__, "Failed to connect to submission host\n"); return OPH_LIBSSH_ERROR; } pthread_mutex_lock(&libssh2_flag); // Lock the access to SSH library pmesg_safe(&global_flag, LOG_DEBUG, __FILE__, __LINE__, "SSH2 library locked\n"); rc = libssh2_init(0); if (rc != 0) { #ifdef WIN32 closesocket(sock); #else close(sock); #endif pthread_mutex_unlock(&libssh2_flag); pmesg_safe(&global_flag, LOG_ERROR, __FILE__, __LINE__, "libssh2 initialization failed (%d)\n", rc); return OPH_LIBSSH_ERROR; } session = libssh2_session_init(); if (!session) { #ifdef WIN32 closesocket(sock); #else close(sock); #endif libssh2_exit(); pthread_mutex_unlock(&libssh2_flag); pmesg_safe(&global_flag, LOG_ERROR, __FILE__, __LINE__, "Failed to init ssh sessione\n"); return OPH_LIBSSH_ERROR; } libssh2_session_set_blocking(session, 0); while ((rc = libssh2_session_handshake(session, sock)) == LIBSSH2_ERROR_EAGAIN); if (rc) { libssh2_session_disconnect(session, "Session disconnected"); libssh2_session_free(session); #ifdef WIN32 closesocket(sock); #else close(sock); #endif libssh2_exit(); pthread_mutex_unlock(&libssh2_flag); pmesg_safe(&global_flag, LOG_ERROR, __FILE__, __LINE__, "Failure establishing SSH session: %d\n", rc); return OPH_LIBSSH_ERROR; } while ((rc = libssh2_userauth_publickey_fromfile(session, oph_subm_user, oph_subm_user_publk, oph_subm_user_privk, "")) == LIBSSH2_ERROR_EAGAIN); if (rc) { libssh2_session_disconnect(session, "Session disconnected"); libssh2_session_free(session); #ifdef WIN32 closesocket(sock); #else close(sock); #endif libssh2_exit(); pthread_mutex_unlock(&libssh2_flag); pmesg_safe(&global_flag, LOG_ERROR, __FILE__, __LINE__, "Authentication by public key failed\n"); return OPH_LIBSSH_ERROR; } while ((channel = libssh2_channel_open_session(session)) == NULL && libssh2_session_last_error(session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock, session); } if (channel == NULL) { libssh2_session_disconnect(session, "Session disconnected"); libssh2_session_free(session); #ifdef WIN32 closesocket(sock); #else close(sock); #endif libssh2_exit(); pthread_mutex_unlock(&libssh2_flag); pmesg_safe(&global_flag, LOG_ERROR, __FILE__, __LINE__, "Error during opening session channel\n"); return OPH_LIBSSH_ERROR; } while ((rc = libssh2_channel_exec(channel, cmd)) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock, session); } if (rc != 0) { libssh2_channel_free(channel); libssh2_session_disconnect(session, "Session disconnected"); libssh2_session_free(session); #ifdef WIN32 closesocket(sock); #else close(sock); #endif libssh2_exit(); pthread_mutex_unlock(&libssh2_flag); pmesg_safe(&global_flag, LOG_ERROR, __FILE__, __LINE__, "Error during opening session channel\n"); return OPH_LIBSSH_ERROR; } int flag = 0; for (;;) { int rc; do { char buffer[0x4000]; rc = libssh2_channel_read(channel, buffer, sizeof(buffer)); if (rc > 0) { int i; bytecount += rc; if (!flag) { pmesg_safe(&global_flag, LOG_DEBUG, __FILE__, __LINE__, "ssh submission returned:\n"); flag = 1; } for (i = 0; i < rc; ++i) pmesg_safe(&global_flag, LOG_DEBUG, __FILE__, __LINE__, "%c\n", buffer[i]); } else if (rc != LIBSSH2_ERROR_EAGAIN) pmesg_safe(&global_flag, LOG_DEBUG, __FILE__, __LINE__, "ssh channel read returned %d\n", rc); } while (rc > 0); if (rc == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock, session); } else break; } exitcode = 127; while ((rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN) waitsocket(sock, session); if (rc == 0) { exitcode = libssh2_channel_get_exit_status(channel); libssh2_channel_get_exit_signal(channel, &exitsignal, NULL, NULL, NULL, NULL, NULL); } if (exitsignal) pmesg_safe(&global_flag, LOG_DEBUG, __FILE__, __LINE__, "ssh got signal %s\n", exitsignal); else pmesg_safe(&global_flag, LOG_DEBUG, __FILE__, __LINE__, "ssh exit code %d with: bytecount %d\n", exitcode, bytecount); libssh2_channel_free(channel); channel = NULL; libssh2_session_disconnect(session, "Session ended normally"); libssh2_session_free(session); #ifdef WIN32 closesocket(sock); #else close(sock); #endif pmesg_safe(&global_flag, LOG_DEBUG, __FILE__, __LINE__, "Session ended normally\n"); libssh2_exit(); pthread_mutex_unlock(&libssh2_flag); // Release the lock for SSH library pmesg_safe(&global_flag, LOG_DEBUG, __FILE__, __LINE__, "SSH2 library unlocked\n"); return OPH_LIBSSH_OK; }
/** * seashell_tunnel_connect_password (const char* host, const char* user, const char* password, int* error) * Connects to the host via SSH on port 22, and launches a Seashell backend instance for that user * on the host. * * Consults /etc/seashell_hosts for host's SSH public keys. If this file does not exist, * this function will fail for security reasons. /etc/seashell_hosts is a standard * OpenSSH known_hosts file. * * Arguments: * host - Host to connect to. * user - User to run as. * password - User's password. * error - [optional] denotes error on failure. * remote_addr - Address to which the remote IP address will * be written. Reserve 128 bytes. * family - Address family. * target - Target to execute. * * Returns: * Handle to connection object on success, NULL otherwise. * If error is NOT null, error will hold more detailed error information. */ struct seashell_connection* seashell_tunnel_connect_password (const char* host, const char* user, const char* password, int* error, char * remote_addr, int* family, char* target) { struct addrinfo hints; struct addrinfo *results, *rp; int sockfd; int i, e; struct seashell_connection* result = NULL; /* Resolve the host's address. * See getaddrinfo(3) for how this works. */ memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = 0; hints.ai_protocol = 0; e = getaddrinfo(host, "22", &hints, &results); if (e != 0) { SET_ERROR(TUNNEL_ERROR_RESOLV); return NULL; } for (rp = results; rp != NULL; rp = rp->ai_next) { sockfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); if (sockfd == -1) continue; if (connect(sockfd, rp->ai_addr, rp->ai_addrlen) != -1) break; close(sockfd); } /* Write address that we're connecting to into * remote_addr. */ if(rp != NULL) { *family = rp->ai_family; switch(rp->ai_family) { case AF_INET: if(inet_ntop(rp->ai_family, &((struct sockaddr_in *)rp->ai_addr)->sin_addr, remote_addr, 128) == NULL) { SET_ERROR(TUNNEL_ERROR_RESOLV); return NULL; } break; case AF_INET6: if(inet_ntop(rp->ai_family, &((struct sockaddr_in6 *)rp->ai_addr)->sin6_addr, remote_addr, 128) == NULL) { SET_ERROR(TUNNEL_ERROR_RESOLV); return NULL; } break; default: SET_ERROR(TUNNEL_ERROR_RESOLV); return NULL; } } freeaddrinfo(results); /* Either rp == NULL, in which case we failed at connecting, * or sockfd holds our socket. */ if (rp == NULL) { SET_ERROR(TUNNEL_ERROR_CONNECT); return NULL; } /** Set up the session */ LIBSSH2_SESSION* session; LIBSSH2_CHANNEL* channel; LIBSSH2_KNOWNHOSTS* hosts; size_t len; int type; session = libssh2_session_init(); if (!session) { SET_ERROR(TUNNEL_ERROR_SESSION_START); goto session_teardown; } e = libssh2_session_handshake(session, sockfd); if (e) { SET_ERROR(TUNNEL_ERROR_SESSION_HANDSHAKE); goto session_teardown; } hosts = libssh2_knownhost_init(session); if (!hosts) { SET_ERROR(TUNNEL_ERROR_HOSTS_FILE); goto session_teardown; } if (!IS_INSTALLED() && access(DEBUG_HOSTS_FILE, F_OK) != -1) { libssh2_knownhost_readfile(hosts, DEBUG_HOSTS_FILE, LIBSSH2_KNOWNHOST_FILE_OPENSSH); } else { libssh2_knownhost_readfile(hosts, HOSTS_FILE, LIBSSH2_KNOWNHOST_FILE_OPENSSH); } const char* fingerprint = libssh2_session_hostkey(session, &len, &type); if (!fingerprint || type == LIBSSH2_HOSTKEY_TYPE_UNKNOWN) { libssh2_knownhost_free(hosts); SET_ERROR(TUNNEL_ERROR_HOST); goto session_teardown; } struct libssh2_knownhost *hostkey; /** NOTE: Documentation is buggy. hostkey MUST be passed. */ int check = libssh2_knownhost_check(hosts, host, fingerprint, len, LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW, &hostkey); if (check != LIBSSH2_KNOWNHOST_CHECK_MATCH) { int keytype = 0; switch (type) { case LIBSSH2_HOSTKEY_TYPE_RSA: keytype = LIBSSH2_KNOWNHOST_KEY_SSHRSA; break; case LIBSSH2_HOSTKEY_TYPE_DSS: keytype = LIBSSH2_KNOWNHOST_KEY_SSHRSA; break; } if (keytype) { libssh2_knownhost_addc(hosts, host, NULL, fingerprint, len, "Generated from Seashell Tunnel", strlen("Generated from Seashell Tunnel"), LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW | (type == LIBSSH2_HOSTKEY_TYPE_RSA ? LIBSSH2_KNOWNHOST_KEY_SSHRSA : LIBSSH2_KNOWNHOST_KEY_SSHDSS), NULL); libssh2_knownhost_writefile(hosts, DUMP_FILE, LIBSSH2_KNOWNHOST_FILE_OPENSSH); fprintf(stderr, "%s: Check SSH key for %s! Keys written to %s\n", user, host, DUMP_FILE); } else { fprintf(stderr, "%s: Check SSH key for %s!\n", user, host, DUMP_FILE); fprintf(stderr, "%s: Keys not written to file - contact Seashell Maintainers to add support for the LibSSH2 key format %d\n", user, type); } libssh2_knownhost_free(hosts); SET_ERROR(TUNNEL_ERROR_HOST); goto session_teardown; } libssh2_knownhost_free(hosts); FPRINTF_IF_DEBUG(stderr, "%s: Host check passed for %s (fingerprint type %d) - ", user, host, type); for(i = 0; i < 20; i++) { FPRINTF_IF_DEBUG(stderr, "%02X ", (unsigned char)fingerprint[i]); } FPRINTF_IF_DEBUG(stderr, "\n"); e = libssh2_userauth_password(session, user, password); if (e) { FPRINTF_IF_DEBUG(stderr, "%s: Error authenticating: %d\n", user, e); SET_ERROR(TUNNEL_ERROR_CREDS); goto session_teardown; } channel = libssh2_channel_open_session(session); if (!channel) { SET_ERROR(TUNNEL_ERROR_CHANNEL_OPEN); goto session_teardown; } /** * Ideally we'd have a subsystem configured, * as I don't see a good way of pulling out of ssh2 * if the target does not exist. */ e = libssh2_channel_exec(channel, target); if (e) { SET_ERROR(TUNNEL_ERROR_LAUNCH_SEASHELL); goto channel_teardown; } result = malloc(sizeof(struct seashell_connection)); if (!result) { SET_ERROR(TUNNEL_ERROR_SESSION_START); goto channel_teardown; } result->sockfd = sockfd; result->session = session; result->channel = channel; goto end; channel_teardown: libssh2_channel_free(channel); session_teardown: libssh2_session_free(session); close(sockfd); end: return result; }
int ssh::exec_cmd(const string &command) { int rc; /* Exec non-blocking on the remove host */ while( (channel = libssh2_channel_open_session(session)) == NULL && libssh2_session_last_error(session,NULL,NULL,0) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(_sock_fd, session); } if( channel == NULL ) { cout << "Error" << std::endl; exit( 1 ); } while( (rc = libssh2_channel_exec(channel, command.c_str())) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(_sock_fd, session); } if( rc != 0 ) { cout << "Error" << std::endl; exit( 1 ); } for( ;; ) { /* loop until we block */ int rc; do { char buffer[0x4000]; rc = libssh2_channel_read( channel, buffer, sizeof(buffer) ); if( rc > 0 ) { /* int i; bytecount += rc;*/ /* cout << "We read: " << std::endl;*/ cout << "[" << _ip_addr << "]====start====== " << std::endl; /*for( i=0; i < rc; ++i ) fputc( buffer[i], stderr);*/ cout << buffer; cout << "[" << _ip_addr << "]====end======== " << std::endl; } /*else { if( rc != LIBSSH2_ERROR_EAGAIN ) no need to output this for the EAGAIN case cout << "libssh2_channel_read returned " << rc << std::endl; }*/ } while( rc > 0 ); do { char buffer2[0x4000]; rc = libssh2_channel_read_stderr( channel, buffer2, sizeof(buffer2) ); if( rc > 0 ) { /* int i; bytecount += rc;*/ /*cout << "We read: " << std::endl;*/ cout << "[" << _ip_addr << "]====start====== " << std::endl; /*for( i=0; i < rc; ++i ) fputc( buffer[i], stderr);*/ cout << buffer2; cout << "[" << _ip_addr << "]====end======== " << std::endl; } /*else { if( rc != LIBSSH2_ERROR_EAGAIN ) no need to output this for the EAGAIN case cout << "libssh2_channel_read_stderr returned " << rc << std::endl; }*/ } while( rc > 0 ); /* this is due to blocking that would occur otherwise so we loop on this condition */ if( rc == LIBSSH2_ERROR_EAGAIN ) { waitsocket(_sock_fd, session); } else break; } quit_channel(); return 0; }
int Parser::runCommand(QString command) { // command channel //------------setup channel ---------------------- LIBSSH2_CHANNEL *channel = NULL; channel = libssh2_channel_open_session(session_); if ( channel == NULL ) { qDebug()<<"Failed to open a new channel\n"; socket_->disconnectFromHost(); return -1; } /* Force Data to on STDOUT and STDERR to be on seperate channels * read individually with *_read and *_read_stderr functions */ libssh2_channel_handle_extended_data(channel,LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL); libssh2_channel_set_blocking(channel, 1); { int rc; while ((rc=libssh2_channel_exec(channel, command.toLocal8Bit().constData()))==LIBSSH2_ERROR_EAGAIN ); if (rc) { return -1; } //-------read channel----------- int read; QString stdout_str; QString stderr_str; while(true) { //qDebug("libssh2_channel_read() >>>"); { QByteArray byte_array; byte_array.resize(4096); char* buffer=byte_array.data(); int buffer_size=byte_array.size(); read = libssh2_channel_read(channel, buffer, buffer_size-10); if(read>0) { QByteArray debug = QByteArray(buffer, read); stdout_str.append(debug); } if(LIBSSH2_ERROR_EAGAIN == read) { qDebug("LIBSSH2_ERROR_EAGAIN"); break; } else if(read < 0) { qDebug(" error reading from std channel"); closeChannel(channel); goto next_channel; } } { QByteArray byte_array; byte_array.resize(4096); char* buffer=byte_array.data(); int buffer_size=byte_array.size(); read = libssh2_channel_read_stderr(channel, buffer, buffer_size-10); if(read>0) { QByteArray debug = QByteArray(buffer, read); stderr_str.append(debug); } if(LIBSSH2_ERROR_EAGAIN == read) { qDebug("LIBSSH2_ERROR_EAGAIN"); break; } else if(read < 0) { qDebug(" error reading from stderr channel"); closeChannel(channel); goto next_channel; } } int i = libssh2_channel_eof(channel); if(i) { //qDebug("libssh2_channel_eof %i", i); closeChannel(channel); goto next_channel; } } next_channel: if(!stdout_str.isEmpty()) { qDebug()<<"STDOUT:\n"<<stdout_str; } if(!stderr_str.isEmpty()) { qDebug()<<"STDERR:\n"<<stderr_str; } } return 1; }
int execute_command(struct remote *rm) { /* Sets up the pthread functionality of gcrypt * libssh2 doesn't do this for us so we have to do it ourselves*/ gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread); openlog("remote-monitor-base",LOG_PID|LOG_CONS,LOG_USER); syslog(LOG_DEBUG,"Starting SSH execution on rm->hostname: %s with rm->username: %s and port: %d",rm->hostname,rm->username,rm->port); size_t len; int type; unsigned long hostaddress; int sock; const char *fingerprint; int bytecount = 0; struct sockaddr_in sin; LIBSSH2_SESSION *session; LIBSSH2_CHANNEL *channel; LIBSSH2_KNOWNHOSTS *nh; /* results stores the output from the commands after they're executed * Each command has a corresponding result so the results array is set to the same length as the commands array */ rm->results = malloc(rm->num_commands * sizeof(char*)); for(int i = 0; i < rm->num_commands; i++) rm->results[i] = malloc(2048 * sizeof(char)); /* Initialise libssh2 and check to see if it was initialized properly * libssh2_init isn't thread safe so we need to lock the thread while it executes*/ pthread_mutex_lock(&sshinit_lock); int rc = libssh2_init(0); pthread_mutex_unlock(&sshinit_lock); if(rc!=0) { syslog(LOG_ERR,"libssh2 initilization failed"); return 1; } /* Creates a socket connection to the specified host on the specified port */ hostaddress = inet_addr(rm->hostname); sock = socket(AF_INET, SOCK_STREAM, 0); sin.sin_family = AF_INET; sin.sin_port = htons(rm->port); sin.sin_addr.s_addr = hostaddress; /* Check to see if the connection was successful */ if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in)) != 0) { syslog(LOG_ERR,"Failed to connect to %s on port %d", rm->hostname, rm->port); return 1; } /* Initialise the session and check for success */ session = libssh2_session_init(); if(!session) { syslog(LOG_ERR,"Error creating session on host %s", rm->hostname); return 1; } /* Disable blocking for this session */ libssh2_session_set_blocking(session,0); /* Start the session on the specified socket and check for success */ while( (rc = libssh2_session_startup(session,sock)) == LIBSSH2_ERROR_EAGAIN); if(rc) { syslog(LOG_ERR,"Failure establishing SSH session %d on host %s", rc, rm->hostname); goto error; } /* Get the current host key and check to see if it matches with any known hosts */ nh = libssh2_knownhost_init(session); if(!nh) { syslog(LOG_ERR,"Error while initialising known hosts collection on host %s",rm->hostname); goto error; } libssh2_knownhost_readfile(nh,"known_hosts",LIBSSH2_KNOWNHOST_FILE_OPENSSH); //libssh2_knownhost_writefile(nh,"dumpfile",LIBSSH2_KNOWNHOST_FILE_OPENSSH); fingerprint = libssh2_session_hostkey(session,&len,&type); if(fingerprint) { struct libssh2_knownhost *host; int check = libssh2_knownhost_checkp(nh,rm->hostname,rm->port,fingerprint,len ,LIBSSH2_KNOWNHOST_TYPE_PLAIN|LIBSSH2_KNOWNHOST_KEYENC_RAW,&host); if(check == LIBSSH2_KNOWNHOST_CHECK_MATCH) syslog(LOG_DEBUG,"Found matching host key for host %s",rm->hostname); else if(check == LIBSSH2_KNOWNHOST_CHECK_MISMATCH) syslog(LOG_ERR,"Host key was found but the key's didn't match for host %s",rm->hostname); //TODO Some sort of critical error will need to be generated here else if(check == LIBSSH2_KNOWNHOST_CHECK_NOTFOUND) syslog(LOG_ERR,"No host match was found for %s",rm->hostname); //TODO Have the ability to add the host key here else syslog(LOG_ERR,"There was a failure while attempting to match host keys for host %s",rm->hostname); } else { syslog(LOG_ERR,"Couldn't get host key for host: %s",rm->hostname); goto error; } libssh2_knownhost_free(nh); /* Authenticate with the specified rm->username and passwod and check for success */ // TODO Add ability to authenticate with a private key if( (strlen(rm->password)) != 0 ) { syslog(LOG_DEBUG,"Using rm->password authentication for host %s",rm->hostname); while( (rc = libssh2_userauth_password(session,rm->username,rm->password)) == LIBSSH2_ERROR_EAGAIN); if(rc) { syslog(LOG_ERR,"Authentication to host %s failed",rm->hostname); goto error; } } else if( ( (strlen(rm->publickey)) != 0 ) && ( ( strlen(rm->privatekey)) != 0) ) { syslog(LOG_DEBUG,"Using public key authentication for host %s",rm->hostname); while( (rc = libssh2_userauth_publickey_fromfile(session,rm->username,rm->publickey,rm->privatekey,NULL)) == LIBSSH2_ERROR_EAGAIN); switch(rc) { case 0: break; case LIBSSH2_ERROR_AUTHENTICATION_FAILED: syslog(LOG_ERR,"Authentication using the supplied key for host %s was not accepted",rm->hostname); goto error; case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED: syslog(LOG_ERR,"The rm->username/public key combination was invalid for host %s",rm->hostname); goto error; default: syslog(LOG_ERR,"Authentication to host %s failed",rm->hostname); goto error; } } /* Open a session for each command */ for(int i = 0; i < rm->num_commands; i++) { /* Open a channel on the current channel and check for success */ while( (channel = libssh2_channel_open_session(session)) == NULL && libssh2_session_last_error(session,NULL,NULL,0) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock,session); } if(channel == NULL) { syslog(LOG_ERR,"Error opening SSH channel on host %s",rm->hostname); asprintf(&(rm->results[i]),NULL); break; } /* Execute the command and check for success */ while( (rc = libssh2_channel_exec(channel,rm->commands[i])) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock,session); } if(rc!=0) { syslog(LOG_ERR,"Error while executing %s in channel on host %s",rm->commands[i],rm->hostname); asprintf(&(rm->results[i]),NULL); break; } /* Continuously read the returned stream and break once the stream has been read */ for(;;) { int rc; do { char buffer[2048]; rc = libssh2_channel_read(channel,buffer,sizeof(buffer)); if(rc > 0) { bytecount += rc; char *output; output = buffer; syslog(LOG_ERR,"Got output from command %s on host %s:%s",rm->commands[i],rm->hostname,output); /* Store the output in the results array */ asprintf(&(rm->results[i]),"%s",output); memset(buffer,0,2048); } } while(rc > 0); if(rc == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock,session); } else break; } /* Close the channel and check for success */ while( (rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN) { waitsocket(sock,session); } if( (libssh2_channel_free(channel)) < 0) syslog(LOG_ERR,"Error while freeing channel on host %s",rm->hostname); channel = NULL; } shutdown: syslog(LOG_DEBUG,"Disconnecting SSH session for host %s",rm->hostname); libssh2_session_disconnect(session,"Normal SSH disconnection"); libssh2_session_free(session); close(sock); libssh2_exit(); closelog(); return 0; error: syslog(LOG_DEBUG,"Disconnection SSH session for host %s",rm->hostname); libssh2_session_disconnect(session,"Normal SSH disconnection"); libssh2_session_free(session); close(sock); libssh2_exit(); closelog(); return 1; }
bool ShellChannel::handleOpening() { int rc; if (mInternalStatus == _OpenSession) { mHandle = libssh2_channel_open_session(mSession->sessionHandle()); if (mHandle == NULL) { int rc = libssh2_session_last_errno(mSession->sessionHandle()); if (rc == LIBSSH2_ERROR_EAGAIN) return true; else { if (rc == LIBSSH2_ERROR_CHANNEL_FAILURE) // This channel needs to be given away; this connection can't handle it. // TODO: Detect if this channel request has been handed off too often and kill it if so. setSession(NULL); else criticalError(tr("Failed to open a channel %1: %2").arg((unsigned long)mHandle, 0, 16).arg(rc)); return false; } } setInternalStatus(_RequestPty); } if (mInternalStatus == _RequestPty) { // Due to a bug in OpenSSH (popular server-side implementation of SSH), we must simulate blocking for PTY request. while ((rc = libssh2_channel_request_pty(mHandle, mPtyType)) == LIBSSH2_ERROR_EAGAIN) {}; if (rc < 0) { criticalError(tr("Failed to request an appropriate pty %1: %2").arg((unsigned long)mHandle, 0, 16).arg(rc)); return false; } setInternalStatus(_StartShell); } if (mInternalStatus == _StartShell) { if (mMachineReadable) rc = libssh2_channel_exec(mHandle, "sh"); else rc = libssh2_channel_shell(mHandle); if (rc < 0) { if (rc == -1) rc = libssh2_session_last_errno(mSession->sessionHandle()); if (rc == LIBSSH2_ERROR_EAGAIN) return true; criticalError(tr("Failed to open a shell %1: %2").arg((unsigned long)mHandle, 0, 16).arg(rc)); return false; } if (mMachineReadable) setInternalStatus(_SendInit); else shellReady(); } if (mInternalStatus == _SendInit) { SendResponse r = sendData(MACHINE_READABLE_INIT); if (r == SendAgain) return true; if (r != SendSucceed) criticalError("Failed to send shell initializer"); setInternalStatus(_WaitForInitReply); } if (mInternalStatus == _WaitForInitReply) { ReadReply reply = readUntilPrompt(); if (reply.readAgain) return true; if (reply.data.isNull()) return false; shellReady(); } return true; }
static int exec_channel_command_exec(SSH_SESSION* p_session, const char* command, int (*callback)(char*, const char*, void*), void* obj) { char* buffer; int buffer_length = COMMAND_RESULT_BUFFER_LENGTH; int ec; int result_code; LIBSSH2_CHANNEL* channel; while((ec = libssh2_channel_exec(p_session->session_param->channel, command)) == LIBSSH2_ERROR_EAGAIN) { waitsocket(p_session->session_param->sock, p_session->session_param->session, TIMEOUT_SEC); } if(ec < 0) { debug_log(SSH_TERMINAL_COMMAND_EXEC_ERROR, "sync_command_exec : channel exec failed."); return SSH_TERMINAL_COMMAND_EXEC_ERROR; } buffer = (char*)malloc(sizeof(char) * (buffer_length + 1)); while(1) { do{ memset(buffer, 0, buffer_length + 1); ec = libssh2_channel_read(p_session->session_param->channel, buffer, buffer_length); if(ec == 0) { ec = libssh2_channel_read_stderr(p_session->session_param->channel, buffer, buffer_length); } if(ec > 0) { callback(buffer, command, obj); } } while(ec > 0); if(ec == LIBSSH2_ERROR_EAGAIN) { waitsocket(p_session->session_param->sock, p_session->session_param->session, TIMEOUT_SEC); } else { break; } } free(buffer); if(ec < 0) { debug_log(SSH_TERMINAL_CHANNEL_READ_ERROR, "sync_command_exec : channel read failed."); result_code = SSH_TERMINAL_CHANNEL_READ_ERROR; } else { result_code = 0; } while(libssh2_channel_close(p_session->session_param->channel) == LIBSSH2_ERROR_EAGAIN) { waitsocket(p_session->session_param->sock, p_session->session_param->session, TIMEOUT_SEC); } libssh2_channel_free(p_session->session_param->channel); while((channel = libssh2_channel_open_session(p_session->session_param->session)) == NULL && libssh2_session_last_error(p_session->session_param->session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN) { waitsocket(p_session->session_param->sock, p_session->session_param->session, TIMEOUT_SEC); } if(channel == NULL) { result_code = SSH_TERMINAL_CHANNEL_OPEN_ERROR; } p_session->session_param->channel = channel; return result_code; }
void Exec::run() { qDebug() << "SecureConnection::Exec::run " << m_command; // Exececute non-blocking on the remote host libssh2_session_set_blocking(m_session, 0); LIBSSH2_CHANNEL *channel; while ( (channel = libssh2_channel_open_session(m_session)) == 0 && libssh2_session_last_error(m_session, 0, 0, 0) == LIBSSH2_ERROR_EAGAIN) { waitsocket(); } if (channel == 0) throw Exception("Failed to open exec channel"); int rc(0); QByteArray cmd(m_command.toLocal8Bit()); while ( (rc = libssh2_channel_exec(channel, cmd.data())) == LIBSSH2_ERROR_EAGAIN) { waitsocket(); } std::string output; int bytecount(0); if (rc == 0) { for ( ; ; ) { // loop until we block int bc; char buffer[0x400]; do { bc = libssh2_channel_read(channel, buffer, sizeof(buffer)); if (bc > 0) { output.append(buffer, bc); bytecount += bc; } //qDebug() <<" sleeping 5"; sleep(5); } while( bc > 0 && !m_terminate); if (m_terminate) break; // this is due to blocking that would occur // otherwise so we loop on this condition if (bc == LIBSSH2_ERROR_EAGAIN) { waitsocket(); }else { break; } } }else { m_errorMessage = "Failed to execute command: " + m_command; } while ( (rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(); } if (!m_terminate) { char *exitsignal=(char *)"none"; if (rc == 0) { libssh2_channel_get_exit_signal(channel, &exitsignal, 0, 0, 0, 0, 0); } if (exitsignal) { m_errorMessage += "\nClose on channel received signal " + QString(exitsignal); } } libssh2_channel_free(channel); if (!m_errorMessage.isEmpty()) throw Exception(m_errorMessage); if (!m_terminate) m_outputMessage = QString::fromStdString(output).trimmed(); qDebug() << " return:" << m_outputMessage; }
/* example ssh.run["ls /"] */ static int ssh_run(DC_ITEM *item, AGENT_RESULT *result, const char *encoding) { const char *__function_name = "ssh_run"; zbx_sock_t s; LIBSSH2_SESSION *session; LIBSSH2_CHANNEL *channel; int auth_pw = 0, rc, ret = NOTSUPPORTED, exitcode, bytecount = 0; char buffer[MAX_BUFFER_LEN], buf[16], *userauthlist, *publickey = NULL, *privatekey = NULL, *ssherr; size_t sz; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name); if (FAIL == zbx_tcp_connect(&s, CONFIG_SOURCE_IP, item->interface.addr, item->interface.port, 0)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot connect to SSH server: %s", zbx_tcp_strerror())); goto close; } /* initializes an SSH session object */ if (NULL == (session = libssh2_session_init())) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot initialize SSH session")); goto tcp_close; } /* set blocking mode on session */ libssh2_session_set_blocking(session, 1); /* Create a session instance and start it up. This will trade welcome */ /* banners, exchange keys, and setup crypto, compression, and MAC layers */ if (0 != libssh2_session_startup(session, s.socket)) { libssh2_session_last_error(session, &ssherr, NULL, 0); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot establish SSH session: %s", ssherr)); goto session_free; } /* check what authentication methods are available */ if (NULL != (userauthlist = libssh2_userauth_list(session, item->username, strlen(item->username)))) { if (NULL != strstr(userauthlist, "password")) auth_pw |= 1; if (NULL != strstr(userauthlist, "keyboard-interactive")) auth_pw |= 2; if (NULL != strstr(userauthlist, "publickey")) auth_pw |= 4; } else { libssh2_session_last_error(session, &ssherr, NULL, 0); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain authentication methods: %s", ssherr)); goto session_close; } zabbix_log(LOG_LEVEL_DEBUG, "%s() supported authentication methods:'%s'", __function_name, userauthlist); switch (item->authtype) { case ITEM_AUTHTYPE_PASSWORD: if (auth_pw & 1) { /* we could authenticate via password */ if (0 != libssh2_userauth_password(session, item->username, item->password)) { libssh2_session_last_error(session, &ssherr, NULL, 0); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Password authentication failed: %s", ssherr)); goto session_close; } else zabbix_log(LOG_LEVEL_DEBUG, "%s() password authentication succeeded", __function_name); } else if (auth_pw & 2) { /* or via keyboard-interactive */ password = item->password; if (0 != libssh2_userauth_keyboard_interactive(session, item->username, &kbd_callback)) { libssh2_session_last_error(session, &ssherr, NULL, 0); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Keyboard-interactive authentication" " failed: %s", ssherr)); goto session_close; } else zabbix_log(LOG_LEVEL_DEBUG, "%s() keyboard-interactive authentication succeeded", __function_name); } else { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Unsupported authentication method." " Supported methods: %s", userauthlist)); goto session_close; } break; case ITEM_AUTHTYPE_PUBLICKEY: if (auth_pw & 4) { if (NULL == CONFIG_SSH_KEY_LOCATION) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Authentication by public key failed." " SSHKeyLocation option is not set")); goto session_close; } /* or by public key */ publickey = zbx_dsprintf(publickey, "%s/%s", CONFIG_SSH_KEY_LOCATION, item->publickey); privatekey = zbx_dsprintf(privatekey, "%s/%s", CONFIG_SSH_KEY_LOCATION, item->privatekey); if (SUCCEED != zbx_is_regular_file(publickey)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot access public key file %s", publickey)); goto session_close; } if (SUCCEED != zbx_is_regular_file(privatekey)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot access private key file %s", privatekey)); goto session_close; } rc = libssh2_userauth_publickey_fromfile(session, item->username, publickey, privatekey, item->password); zbx_free(publickey); zbx_free(privatekey); if (0 != rc) { libssh2_session_last_error(session, &ssherr, NULL, 0); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Public key authentication failed:" " %s", ssherr)); goto session_close; } else zabbix_log(LOG_LEVEL_DEBUG, "%s() authentication by public key succeeded", __function_name); } else { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Unsupported authentication method." " Supported methods: %s", userauthlist)); goto session_close; } break; } /* exec non-blocking on the remove host */ while (NULL == (channel = libssh2_channel_open_session(session))) { switch (libssh2_session_last_error(session, NULL, NULL, 0)) { /* marked for non-blocking I/O but the call would block. */ case LIBSSH2_ERROR_EAGAIN: waitsocket(s.socket, session); continue; default: SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot establish generic session channel")); goto session_close; } } dos2unix(item->params); /* CR+LF (Windows) => LF (Unix) */ /* request a shell on a channel and execute command */ while (0 != (rc = libssh2_channel_exec(channel, item->params))) { switch (rc) { case LIBSSH2_ERROR_EAGAIN: waitsocket(s.socket, session); continue; default: SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot request a shell")); goto channel_close; } } for (;;) { /* loop until we block */ do { if (0 < (rc = libssh2_channel_read(channel, buf, sizeof(buf)))) { sz = (size_t)rc; if (sz > MAX_BUFFER_LEN - (bytecount + 1)) sz = MAX_BUFFER_LEN - (bytecount + 1); if (0 == sz) continue; memcpy(buffer + bytecount, buf, sz); bytecount += sz; } } while (rc > 0); /* this is due to blocking that would occur otherwise so we loop on * this condition */ if (LIBSSH2_ERROR_EAGAIN == rc) waitsocket(s.socket, session); else if (rc < 0) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot read data from SSH server")); goto channel_close; } else break; } buffer[bytecount] = '\0'; SET_STR_RESULT(result, convert_to_utf8(buffer, bytecount, encoding)); ret = SYSINFO_RET_OK; channel_close: /* close an active data channel */ exitcode = 127; while (0 != (rc = libssh2_channel_close(channel))) { switch (rc) { case LIBSSH2_ERROR_EAGAIN: waitsocket(s.socket, session); continue; default: libssh2_session_last_error(session, &ssherr, NULL, 0); zabbix_log(LOG_LEVEL_WARNING, "%s() cannot close generic session channel: %s", __function_name, ssherr); break; } } if (0 == rc) exitcode = libssh2_channel_get_exit_status(channel); zabbix_log(LOG_LEVEL_DEBUG, "%s() exitcode: %d bytecount: %d", __function_name, exitcode, bytecount); libssh2_channel_free(channel); channel = NULL; session_close: libssh2_session_disconnect(session, "Normal Shutdown"); session_free: libssh2_session_free(session); tcp_close: zbx_tcp_close(&s); close: zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret)); return ret; }
//获取此分站范围内的设备IP std::string CEasyssh::GetDeviceMAC(void) { if (m_bIsErr) { //自动重连 ConnectAP(); return std::string("Error"); } std::string str_ip_pool = ""; char *exitsignal=(char *)"none"; int rc = 0; const char *commandline = "/usr/www/wstalist ath0"; /* Exec non-blocking on the remove host */ LIBSSH2_CHANNEL *channel; while( (channel = libssh2_channel_open_session(m_ssh_session)) == NULL && libssh2_session_last_error(m_ssh_session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN) { waitsocket(m_sock, m_ssh_session); } if(channel == NULL) { TRACE(_T("libssh2_channel_open_session Error\n")); return std::string("Error"); } while( (rc = libssh2_channel_exec(channel, commandline)) == LIBSSH2_ERROR_EAGAIN) { waitsocket(m_sock, m_ssh_session); } if(rc != 0) { return std::string("Error"); } for( ;; ) { /* loop until we block */ int rc; do { char buffer[0x4000]; rc = libssh2_channel_read(channel, buffer, sizeof(buffer)); if(rc > 0) { std::string str_temp(buffer, 0, rc); str_ip_pool += str_temp; } } while( rc > 0 ); /* this is due to blocking that would occur otherwise so we loop on this condition */ if( rc == LIBSSH2_ERROR_EAGAIN ) { waitsocket(m_sock, m_ssh_session); } else break; } while( (rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN ) waitsocket(m_sock, m_ssh_session); if( rc == 0 ) { libssh2_channel_get_exit_status(channel); libssh2_channel_get_exit_signal(channel, &exitsignal, NULL, NULL, NULL, NULL, NULL); } libssh2_channel_free(channel); channel = NULL; return str_ip_pool; }
bool QxtSshChannelPrivate::activate(){ //session if(d_state==1){ d_channel=libssh2_channel_open_session(d_session); if(d_channel==NULL){ if(libssh2_session_last_error(d_session,NULL,NULL,0)==LIBSSH2_ERROR_EAGAIN) { return true; }else{ return false; } } #ifdef QXT_DEBUG_SSH qDebug("session opened"); #endif d_state=2; return activate(); //transition to allow early cmd }else if (d_state==2){ if(!d_next_actions.isEmpty()){ d_state=d_next_actions.takeFirst(); return activate(); }else{ return true; } //request pty }else if (d_state==5){ int r=libssh2_channel_request_pty(d_channel,d_pty.data()); if(r){ if(r==LIBSSH2_ERROR_EAGAIN){ return true; }else{ qWarning("QxtSshChannel: pty allocation failed"); return false; } } #ifdef QXT_DEBUG_SSH qDebug("pty opened"); #endif d_state=2; return activate(); //start }else if (d_state==3){ int r=libssh2_channel_exec(d_channel,qPrintable(d_cmd)); if(r){ if(r==LIBSSH2_ERROR_EAGAIN){ return true; }else{ #ifdef QXT_DEBUG_SSH qDebug("exec failed"); #endif return false; } } #ifdef QXT_DEBUG_SSH qDebug("exec opened"); #endif p->setOpenMode(QIODevice::ReadWrite); d_state=66; emit p->connected(); return true; //start shell }else if (d_state==4){ int r=libssh2_channel_shell(d_channel); if(r){ if(r==LIBSSH2_ERROR_EAGAIN){ return true; }else{ #ifdef QXT_DEBUG_SSH qDebug("exec failed"); #endif return false; } } #ifdef QXT_DEBUG_SSH qDebug("shell opened"); #endif p->setOpenMode(QIODevice::ReadWrite); d_state=9999; emit p->connected(); return true; // tcp channel }else if (d_state==10){ d_channel=libssh2_channel_direct_tcpip(d_session, qPrintable(d_host),d_port); if(d_channel==NULL){ if(libssh2_session_last_error(d_session,NULL,NULL,0)==LIBSSH2_ERROR_EAGAIN) { return true; }else{ return false; } } #ifdef QXT_DEBUG_SSH qDebug("tcp channel opened"); #endif p->setOpenMode(QIODevice::ReadWrite); d_state=9999; return activate(); //read channel }else if (d_state==9999){ emit p->readyRead(); } return true; }
int ssh_cmd(SSH * pSsh,char * pCmdstr) { int ret=0; int exitcode; char *exitsignal=(char *)"none"; if (NULL==pSsh || NULL==pCmdstr) { return 0; } while( (pSsh->channel = libssh2_channel_open_session(pSsh->session)) == NULL && libssh2_session_last_error(pSsh->session,NULL,NULL,0) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(pSsh->sock_fd, pSsh->session); } if( pSsh->channel == NULL ) { fprintf(stderr,"Error\n"); exit( 1 ); } while( (ret = libssh2_channel_exec(pSsh->channel, pCmdstr)) == LIBSSH2_ERROR_EAGAIN ) { waitsocket(pSsh->sock_fd, pSsh->session); } if( ret != 0 ) { fprintf(stderr,"Error\n"); exit( 1 ); } for( ;; ) { /* loop until we block */ int rc; do { char buffer[0x4000]; rc = libssh2_channel_read( pSsh->channel, buffer, sizeof(buffer) ); if( rc > 0 ) { int i; for( i=0; i < rc; ++i ) fputc( buffer[i], stdout); fprintf(stderr, "\n"); } else { if( ret != LIBSSH2_ERROR_EAGAIN ) /* no need to output this for the EAGAIN case */ fprintf(stderr, "libssh2_channel_read returned %d\n", rc); } } while( ret > 0 ); /* this is due to blocking that would occur otherwise so we loop on this condition */ if( rc == LIBSSH2_ERROR_EAGAIN ) { waitsocket(pSsh->sock_fd, pSsh->session); } else break; } exitcode = 127; while( (ret = libssh2_channel_close(pSsh->channel)) == LIBSSH2_ERROR_EAGAIN ) waitsocket(pSsh->sock_fd, pSsh->session); if( ret == 0 ) { exitcode = libssh2_channel_get_exit_status( pSsh->channel ); libssh2_channel_get_exit_signal(pSsh->channel, &exitsignal, NULL, NULL, NULL, NULL, NULL); } if (exitsignal) fprintf(stderr, "\nGot signal: %s\n", exitsignal); fprintf(stderr,"\n*ssh_cmd::pcmdstr=%s\n",pCmdstr); return 0; }
QString Parser::sshRequest(QString commandline) { QString host_ip(this->sharedHost); QString user_name=this->sharedUser; QString pass_word=this->sharedPass; //---------- connection -------------- int libssh2_error = libssh2_init(0); if(libssh2_error) { qDebug("libssh2_init() error: %d", libssh2_error); //return -2; } QTcpSocket socket; socket.connectToHost(host_ip, 22); if(!socket.waitForConnected()) { qDebug("Error connecting to host %s", host_ip.toLocal8Bit().constData()); //return -1; } LIBSSH2_SESSION *session = libssh2_session_init(); if(!session) { qDebug("libssh2_session_init() failed"); //return -2; } libssh2_error = libssh2_session_startup(session, socket.socketDescriptor()); if(libssh2_error) { qDebug("libssh2_session_startup() error: %d", libssh2_error); //return -3; } { /* At this point we havn't yet authenticated. The first thing to do * is check the hostkey's fingerprint against our known hosts Your app * may have it hard coded, may go to a file, may present it to the * user, that's your call */ const char *fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1); } libssh2_userauth_list(session, user_name.toLocal8Bit().constData(), user_name.toLocal8Bit().length()); if(libssh2_userauth_password( session, user_name.toLocal8Bit().constData(), pass_word.toLocal8Bit().constData() )) { qDebug("Password authentication failed"); socket.disconnectFromHost(); libssh2_session_disconnect(session, "Client disconnecting for error"); libssh2_session_free(session); libssh2_exit(); //return -4; } // command channel //------------setup channel ---------------------- LIBSSH2_CHANNEL *channel = NULL; channel = libssh2_channel_open_session(session); int rc; if ( channel == NULL ) { qDebug()<<"Failed to open a new channel\n"; socket.disconnectFromHost(); //return -1; } libssh2_channel_set_blocking(channel, 1); while ((rc=libssh2_channel_exec(channel, commandline.toLocal8Bit().constData()))==LIBSSH2_ERROR_EAGAIN ); if (rc) { //return -1; } //-------read channel----------- int read; QByteArray byte_array; byte_array.resize(4096); char* buffer=byte_array.data(); int buffer_size=byte_array.size(); QString myOutPut; while(true) { { read = libssh2_channel_read(channel, buffer, buffer_size); QByteArray debug = QByteArray(buffer, read); //qDebug()<<"STDOUT: "<<debug.constData(); myOutPut = debug.constData(); qDebug() << myOutPut; if(LIBSSH2_ERROR_EAGAIN == read) { qDebug("LIBSSH2_ERROR_EAGAIN"); break; } else if(read < 0) { qDebug(" error reading from channel"); closeChannel(channel); goto next_channel; } } { read = libssh2_channel_read_stderr(channel, buffer, buffer_size); QByteArray debug = QByteArray(buffer, read); qDebug()<<"STDERR: "<<debug.constData(); if(LIBSSH2_ERROR_EAGAIN == read) { qDebug("LIBSSH2_ERROR_EAGAIN"); break; } else if(read < 0) { qDebug(" error reading from channel"); closeChannel(channel); goto next_channel; } } int i=0; i = libssh2_channel_eof(channel); if(i) { qDebug("libssh2_channel_eof %i", i); closeChannel(channel); goto next_channel; } } next_channel: //------------ clean session socket.disconnectFromHost(); libssh2_session_disconnect(session, "Client disconnecting normally"); libssh2_session_free(session); libssh2_exit(); return myOutPut; }