UNIX/Linux CIB : Lecture à partir d'un tuyau. Comment savoir la longueur de données au moment de l'exécution?

Puisqu'il semble que vous avez l'intention de faire une seule lecture de toutes les données de la pipe, je pense que la suite va vous servir mieux que séparateur+encodage ou miniheader techniques suggéré dans d'autres réponses:

De la pipe (7) page de manuel:

Si tous les descripteurs de fichier se référant à
l'écriture, à la fin du tube ont été
fermé, puis une tentative de lecture(2)
de la pipe à voir en fin de fichier
(read(2) renvoie 0).

L'exemple suivant a été prise à partir de la pipe (2) page de manuel et inversées, de sorte que l'enfant ne l'écrit, la mère de la lecture (juste pour être sûr). J'ai également ajouté une variable de la taille de la mémoire tampon. L'enfant va dormir pendant 5 secondes. Le délai sera de s'assurer que la sortie() de l'enfant n'ont rien à voir avec pipeio (le parent doit imprimer une ligne complète avant que l'enfant ne quitte).

#include <sys/wait.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

char *
slurpfd(int fd)
{
    const int bytes_at_a_time = 2;
    char *read_buffer = NULL;
    int buffer_size = 0;
    int buffer_offset = 0;
    int chars_io;
    while (1) {
      if (buffer_offset + bytes_at_a_time > buffer_size) {
        buffer_size = bytes_at_a_time + buffer_size * 2;
        read_buffer = realloc(read_buffer, buffer_size);
        if (!read_buffer) {
          perror("memory");
          exit(EXIT_FAILURE);
        }
      }

      chars_io = read(fd,
                  read_buffer + buffer_offset,
                  bytes_at_a_time);
      if (chars_io <= 0) break;
      buffer_offset += chars_io;
    }

    if (chars_io < 0) {
      perror("read");
      exit(EXIT_FAILURE);
    }

    return read_buffer; /* caller gets to free it */
}

int
main(int argc, char *argv[])
{
  int pipefd[2];
  pid_t cpid;

  assert(argc == 2);

  if (pipe(pipefd) == -1) {
    perror("pipe");
    exit(EXIT_FAILURE);
  }

  cpid = fork();
  if (cpid == -1) {
    perror("fork");
    exit(EXIT_FAILURE);
  }

  if (cpid == 0) {     /* Child writes argv[1] to pipe */
    close(pipefd[0]);  /* Close unused read end */

    write(pipefd[1], argv[1], strlen(argv[1]) + 1);

    close(pipefd[1]);  /* Reader will see EOF */
    /* sleep before exit to make sure that there
       will be a delay after the parent prints it's
       output */
    sleep(5);
    exit(EXIT_SUCCESS);
  } else {             /* Parent reads from pipe */
    close(pipefd[1]);  /* Close unused write end */

    puts(slurpfd(pipefd[0]));

    close(pipefd[0]);
    wait(NULL);        /* Wait for child */
    _exit(EXIT_SUCCESS);
  }
}

De votre commentaire, je vois maintenant que vous voudrez peut-être lire les données qu'il devient disponible, pour mettre à jour l'INTERFACE utilisateur ou que ce soit, afin de refléter l'état de votre système. Pour ouvrir le tuyau de non-blocage (O_NONBLOCK) mode. Lire à plusieurs reprises ce qui est disponible jusqu'à -1 est returnd et errno == EAGAIN et faire votre analyse. Répétez l'unil read retourne 0, ce qui indique que l'enfant a fermé la pipe.

D'utiliser un tampon en mémoire du Fichier* fonctions que vous pouvez utiliser fmemopen() de la bibliothèque C de GNU.

OriginalL'auteur Inshallah

Vous ne pouvez pas obtenir des informations sur la taille d'un tuyau, car il n'y a pas de taille.

Vous devez soit utiliser une taille définie, ou un délimiteur.

En d'autres termes, dans l'enfant, la sortie de la taille de la prochaine sortie comme un int, puis écrire la sortie réelle; dans le parent de vous que vous lisez la taille (c'est un int, il est donc toujours la même taille), puis de lire ce nombre d'octets.

Ou: définir un caractère de fin et jusqu'à ce que vous voyez que, supposons que vous avez besoin de continuer la lecture. Cela peut nécessiter une certaine forme d'échapper à l'/mécanisme de codage, cependant, et ne sera probablement pas aussi vite. Je pense que c'est essentiellement ce que fgets ne.

OriginalL'auteur freiheit

D'autres affiches sont correctes: vous devez avoir un moyen de spécifier la longueur des paquets de vous-même. L'un de béton, moyen pratique de le faire est avec netstrings. Il est simple de créer et d'analyser, et il est pris en charge par certains cadres communs tels que Twisted.

OriginalL'auteur Chris Jester-Young