It seems my questions are strange and i'm not getting enough help but I'm back. I've another strange question which needs to be solved in emergency.

I'm developing an iPhone app. which uses libssh 2 for commands execution through iPhone over remote host. It's okay and working all methods and commands if i execute them in single.

My problem is, consider a sequence of commands,

pwd

=> o/p will be /Users/mac01

cd xyz

=> nothing as o/p

pwd

=> o/p will be /Users/mac01/xyz

So, my question is to save the last state of the command which has been executed... but what I'm getting as o/p is /Users/mac01 after second pwd command execution, which is wrong.

So, could anyone help me out with such type of problems..? Thanks in advance. I'm using libssh 2.0 library.

The method executing command:

char* cmd_exec(const char *commandline, const char *host, const char *username, const char *password, int port){ int sock, rc, bytecount = 0; char *cmd_contents;

if(!he)
{
    struct sockaddr_in sin;

ifdef WIN32

    WSADATA wsadata;
    WSAStartup(MAKEWORD(2,0), &wsadata);

endif

    /* Init and Make Socket Connection  */
    /*  Start Socket Connection         */
    sock = socket(AF_INET, SOCK_STREAM, 0);

ifndef WIN32

    fcntl(sock, F_SETFL, 0);

endif

    sin.sin_family = AF_INET;
    sin.sin_port = htons(port);
    /*sin.sin_addr.s_addr = inet_addr(host);

     if (connect(sock, (struct sockaddr*)(&sin),
     sizeof(struct sockaddr_in)) != 0) {    // in case connection failure
     fprintf(stderr, "Internet connection is required!\n");
     return "NETWORKFAILURE";
     }*/
    //const char *c = getIPFromHost("pepsi");
    //sin.sin_addr.s_addr = inet_addr(c);

    /*      IP Address Calculation  */

    he = gethostbyname(host);

    if(!he)
        return "Invalid hostname";

    struct in_addr **addr_list;
    addr_list = (struct in_addr **)he->h_addr_list;
    //for(int i = 0; addr_list[i] != NULL; i++) {
    if(addr_list != NULL){
        sin.sin_addr.s_addr = inet_addr(inet_ntoa(*addr_list[0]));
        //printf("%s", inet_ntoa(*addr_list[0]));
        if (connect(sock, (struct sockaddr*)(&sin),
                    sizeof(struct sockaddr_in)) != 0) { // in case connection failure
            fprintf(stderr, "Internet connection is required!\n");
            return "NETWORKFAILURE";
        }
    }
}
/*  End Socket Connection           */

// Initialize and create Session Instance
if(!session)
{
    session = libssh2_session_init();
    if ( !session ) 
    { 
        fprintf( stderr, "Error initializing SSH session\n" ); 
        return "SESSIONFAILURE"; 
    }


    /* Since we have set non-blocking, tell libssh2 we are non-blocking */
    //libssh2_session_set_blocking(session, 0);

    // Session starting
    if (libssh2_session_startup(session, sock)) {
        fprintf(stderr, "Failure establishing SSH session\n");
        return "SESSIONFAILURE";
    }

    /* Authenticate via password */ 
    if(strlen(password) != 0){
        if ( libssh2_userauth_password( session, username, password ) ) 
        { 
            fprintf( stderr, "Unable to authenticate user [%s]" 
                    "(wrong password specified?)\n", username ); 
            return "AUTHENTICATIONFAILURE";
        } 
    }else{
        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");
            return "AUTHENTICATIONFAILURE";
        }
    }

    //libssh2_session_set_blocking(session, 1);

}

// Open a session channel for command execution
if(!channel)

{
    channel = libssh2_channel_open_session(session);
if (!channel) {
    fprintf(stderr, "Unable to open a session\n");
    return "SESSIONFAILURE";
}

// Execute a command through channel

while( (rc = libssh2_channel_shell(channel)) ==

//while( (rc = libssh2_channel_exec(channel, commandline)) ==
      LIBSSH2_ERROR_EAGAIN )
{
    waitsocket(sock, session);
}

if( rc != 0 )   // if command execution failed
{
    fprintf(stderr,"Error\n");
    return "CMDFAILURE";
}
}

//libssh2_channel_write(channel,commandline,strlen(commandline));
do {
    /* write the same data over and over, until error or completion */
    rc = libssh2_channel_write(channel, commandline, sizeof(commandline));
    if (rc < 0) {
        fprintf(stderr, "ERROR %d\n", rc);
    }
} while (rc == 0);


while (libssh2_channel_send_eof(channel) == LIBSSH2_ERROR_EAGAIN);

/* read channel output  */
/* Start channel read   */
for( ;; )
{
    /* loop until we block */
    int rc;
    do
    {
        char buffer[0x4000];
//      char *tcontents = (char*)malloc(sizeof(buffer) + sizeof(cmd_contents));
        rc = libssh2_channel_read( channel, 开发者_如何学Pythonbuffer, sizeof(buffer) );
        if( rc > 0 )
        {
            int i;
            bytecount += rc;
            for( i=0; i < rc; ++i )
                fputc( buffer[i], stderr);
            if(cmd_contents){
                free(cmd_contents);
            }
            cmd_contents = (char*)malloc(sizeof(buffer) + sizeof(cmd_contents));
            strcpy(cmd_contents, buffer);
            fprintf(stderr, "\n");
        }
        else {
            //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;
}

/* End channel read */
 while( (rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN );

/*      closing channel */
int exitcode = 127;

// while( (rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN ); if( rc == 0 ) { exitcode = libssh2_channel_get_exit_status( channel ); } //

libssh2_channel_free(channel); // freeup memory channel = NULL;

/*
libssh2_session_disconnect( session, "" );      // closing session
libssh2_session_free( session );                // free up memory
close( sock );                                  // closing socket
*/

return cmd_contents;

}

---

Try this maybe it works... i havent tried it but you can get enough idea and may be the proper solution

libssh2_session_set_blocking(session, 0);
char buffer[0x4000]; rc = libssh2_channel_read( channel, buffer, sizeof(buffer) ); 
for( i=0; i < rc; ++i ) 
   fputc( buffer[i], stderr);
  if(cmd_contents)
  {

    free(cmd_contents);     
 }

  buffer[i] = '\0';
  cmd_contents = (char*)malloc(sizeof(buffer) + sizeof(cmd_contents));
  strcpy(cmd_contents, buffer);
  if( rc == LIBSSH2_ERROR_EAGAIN ) 
  {
    waitsocket(sock, session); 
  }

hAPPY cODING...

---

libssh2_session_set_blocking(session, 0);

char buffer[0x4000]; rc = libssh2_channel_read( channel, buffer, sizeof(buffer) ); for( i=0; i < rc; ++i ) fputc( buffer[i], stderr);

            if(cmd_contents){
                free(cmd_contents);
            }

            buffer[i] = '\0';
            cmd_contents = (char*)malloc(sizeof(buffer) + sizeof(cmd_contents));
            strcpy(cmd_contents, buffer);

if( rc == LIBSSH2_ERROR_EAGAIN ) { waitsocket(sock, session); }