Wie synchronisiert man Eingabe und Ausgabe in Pipes Linux?

Question

Ich erstelle einen Shell-Befehl von der benutzerdefinierten Shell, um den SSH von einem Terminal zu einem anderen Terminal zu tun. Um das ssh zu machen, verwende ich den eingebauten ssh-Befehl des Linux. Hier ist mein Code, der die ssh-Anmeldung ausführt. Ich sehe jedoch, dass die I/O-Puffer nicht synchron sind.

Dies ist, was ich auf dem Terminal sehe. Nach SSH zum anderen Terminal. Ich habe folgendes im Terminal gemacht.

PRT# ssh 192.168.10.42 
PRT# Could not create directory '/root/.ssh'. 
root@192.168.10.42's password: 
# screen -r 
-sh: cen-: not found 
# hello 
-sh: el: not found 
# 

Ich weiß nicht, was ist der Grund hier. Hier ist der Code.

int sshLogin(chr *destIp) 
{ 
    char cmd[CMD_LEN]; 
    char readbuff[CMD_LEN]; 
    pid_t pid; 
    int ret = 0; 
    int fd[2]; 
    int result; 
    memset(cmd,'\0',sizeof(cmd)); 
    int status = 0; 

    /** --tt required to force pseudowire allocation because we are behind screen app **/ 
    sprintf(cmd,"/usr/bin/ssh -tt %s",destIp); 

    /** create a pipe this will be shared on fork() **/ 
    pipe(fd); 

    if((pid = fork()) == -1) 
    { 
     perror("fork:"); 
     return -1; 
    } 
    if(pid == 0) 
    { 
     /** Child Process of Main APP --Make this parent process for the command**/ 

     if((pid = fork()) == -1) 
     { 
      perror("fork:"); 
      return -1; 
     } 

     if(pid == 0) 
     { 
      /** basically Main APP grand child - this is where we running the command **/ 
      ret = execlp("ssh", "ssh", "-tt", destIp, NULL); 
      printf("done execlp\r\n"); 
     } 
     else 
     { 
      /** child of Main APP -- keep this blocked until the Main APP grand child is done with the job **/ 
      while((read(fd[0], readbuff, sizeof(readbuff)))) 
      { 
       printf("%s",readbuff); 
      } 

      waitpid(0,&status,0); 
      LOG_STRING("SSH CONNC CLOSED"); 
      exit(0); 
     } 
    } 
    else 
    { 
     /** Parent process APP MAIN-- **/ 
     /** no need to wait let APP MAIN run -- **/ 
    } 

    return 0; 
} 

auf Patrick Ideen Basierend.

POST 2 # - Es scheint, dass es funktioniert, wenn wir die Stdin im übergeordneten Prozess schließen. Allerdings wird es sehr schlampig, ich fühle mich, als würde ich die Tastatur zu langsam tippen. Das System wird zu träge. Ich habe auch einen Webserver von diesem Terminal. Ich sehe, dass ich nicht mehr auf das Web zugreifen kann. Also, die Lösung ist irgendwo um Stdin, aber ich bin mir nicht sicher.

int sshLogin(chr *destIp) 
    { 
     char cmd[CMD_LEN]; 
     char readbuff[CMD_LEN]; 
     pid_t pid; 
     int ret = 0; 
     int fd[2]; 
     int result; 
     memset(cmd,'\0',sizeof(cmd)); 
     int status = 0; 

     /** --tt required to force pseudowire allocation because we are behind screen app **/ 
     sprintf(cmd,"/usr/bin/ssh -tt %s",destIp); 

     /** create a pipe this will be shared on fork() **/ 
     pipe(fd); 

     if((pid = fork()) == -1) 
     { 
      perror("fork:"); 
      return -1; 
     } 
     if(pid == 0) 
     { 
      /** Child Process of Main APP --Make this parent process for the command**/ 

      if((pid = fork()) == -1) 
      { 
       perror("fork:"); 
       return -1; 
      } 

      if(pid == 0) 
      { 
       /** basically Main APP grand child - this is where we running the command **/ 
       ret = execlp("ssh", "ssh", "-tt", destIp, NULL); 
       printf("done execlp\r\n"); 
      } 
      else 
      { 
       /** child of Main APP -- keep this blocked until the Main APP grand child is done with the job **/ 
       while((read(fd[0], readbuff, sizeof(readbuff)))) 
       { 
        printf("%s",readbuff); 
       } 

       waitpid(0,&status,0); 
       LOG_STRING("SSH CONNC CLOSED"); 
       exit(0); 
      } 
     } 
     else 
     { 
      /** Parent process APP MAIN-- **/ 
      /** no need to wait let APP MAIN run -- **/ 
      close(stdin); 
     } 

     return 0; 
    } 

Grundsätzlich habe ich hinzugefügt - close (stdin);

Answer 1

Sie haben 2 verschiedene Prozesse, die versuchen, von STDIN zu lesen. Dies bewirkt, dass Prozess 1 char 1 erhält, Prozess 2 char 2 erhält, Prozess 1 char 3 abruft, Prozess 2 char r 4 usw. abfragt, abwechselnd hin und her.

Ihre 2 Prozesse sind:

1. execlp("ssh", "ssh", "-tt", destIp, NULL);.
2. while((read(fd[0], readbuff, sizeof(readbuff))))

Grundsätzlich müssen Sie die read(fd[0],...) Graben.

Answer 2

Mein erster Gedanke ist, dass es vielleicht die Ausgabe puffert: stdout ist gepuffert, so dass nichts gedruckt wird, bis Sie eine bestimmte Anzahl von Zeichen aufbauen, es sei denn, Sie drucken eine neue Zeile. Dies liegt daran, dass E/A-Vorgänge teuer sind. Sie können mehr Details zu diesem here finden. Das Ergebnis ist, dass es eine Verzögerung gibt, weil Ihr Programm auf Drucken wartet.

Mein Vorschlag: in Ihre main Funktion, bevor Sie Ihre sshLogin Funktion aufrufen, versuchen Pufferung von Code mit dieser Linie zu deaktivieren:

setbuf(stdout, NULL); 

Sie auch fflush(stdout); regelmäßig die gleiche Sache zu tun nennen kann, aber die Methode oben ist effizienter. Probieren Sie es aus und sehen Sie, ob das Ihr Problem löst.