Provided by: manpages-nl-dev_4.21.0-2_all bug

NAAM

       pipe, pipe2 - maak pipe

BIBLIOTHEEK

       Standard C bibliotheek  (libc, -lc)

SAMENVATTING

       #include <unistd.h>

       int pipe(int pipefd[2]);

       #define _GNU_SOURCE             /* Zie feature_test_macros(7) */
       #include <fcntl.h>              /* Definitie van O_* constanten */
       #include <unistd.h>

       int pipe2(int pipe_bes_ind[2], int vlaggen);

       /* Op Alpha, IA-64, MIPS, SuperH, en SPARC/SPARC64, heeft pipe() het
          volgende prototype; zie NOTITIES */

       #include <unistd.h>

       struct fd_pair {
       long fd[2];
       };
       struct fd_pair pipe(void);

BESCHRIJVING

       pipe()   maakt een pijp aan: een uni-directioneel data kanaal dat kan worden gebruikt voor
       interprocess communicatie.  Het array  pipefd wordt gebruikt om twee  bestandsbeschrijving
       te  retourneren  die  naar  de  uiteinden  van  de  pijp wijzen.  pipefd[0] wijst naar het
       lees-uiteinde van de pijp.  pipefd[1] wijst naar het schrijf-uiteinde van de  pijp.   Data
       geschreven  naar  het  schrijf-uiteinde  van de pijp wordt gebufferd door de kernel totdat
       deze werd gelezen aan het lees-uiteinde van de pijp.  Voor verder details, ziepipe(7).

       Als vlaggen is 0, dan is pipe2()  hetzelfde als pipe().  De volgende  waarden  kunnen  per
       bit worden geOF´ed in vlaggen om ander gedrag te verkrijgen:

       O_CLOEXEC
              Zet  de  sluit-bij-exec  (FD_CLOEXEC)   vlag op twee nieuwe bestandsbeschrijvingen.
              Zie de beschrijving  van  dezelfde  vlag  in  open(2)   voor   redenen  waarom  dit
              bruikbaar kan zijn.

       O_DIRECT (sinds Linux 3.4)
              Maak  een  pijp aan die Invoer/Uitvoer in pakket modus uitvoert. Elke write(2) naar
              de pijp wordt behandeld als een apart pakket, en read(2)s van deze pijp  leest  een
              pakket per tijdseenheid. Let op de volgende punten:

              •  Het  schrijven  van  meer  dan  PIPE_BUF  bytes  (zie pipe(7) wordt gesplitst in
                 meerdere pakketten. De constante PIPE_BUF is gedefinieerd in <limits.h>.

              •  Als  read(2) een buffer grootte opgeeft die kleiner is dan het volgende  pakket,
                 dan  zal  het  gevraagde  aantal bytes worden gelezen, en zullen de overmaat aan
                 bytes in het pakket worden  weggegooid.  Opgeven  van  een  buffer  grootte  van
                 PIPE_BUF  is  voldoende  om  de  grootst  mogelijke  pakketten te lezen (zie het
                 voorgaande punt).

              •  Nul-lengte pakketten worden  niet  ondersteund.  (Een  read(2)  die  een  buffer
                 grootte van nul opgeeft is een ongeldige operatie en geeft 0 terug.)

              Oudere kernels die deze vlag niet ondersteunen zullen dit kenbaar maken door middel
              van een EINVAL fout.

              Vanaf  Linux  4.5  is  het  mogelijk  om  de  O_DIRECT  instelling  van  een   pijp
              bestandsbeschrijving te veranderen met fcntl(2).

       O_NONBLOCK
              Stel   de  O_NONBLOCK  bestandsstatus  vlag  in  op  de  open  bestandsbeschrijving
              aangewezen naar door een nieuwe bestandsbeschrijving. Het gebruiken van  deze  vlag
              bespaart extra aanroepen van fcntl(2) om hetzelfde resultaat te bereiken.

       O_NOTIFICATION_PIPE
              Vanaf  Linux 5.8 is het algemene informatie mechanisme gebouwd bovenop de pipe waar
              de kernel informatie berichten splitst in pipes die worden  geopend  in  gebruikers
              ruimte.  De  eigenaar  van  de  pipe dient de kernel te vertellen welke bronnen van
              gebeurtenissen worden  geobserveerd  en  filters  kunnen  worden  toegepast  om  te
              selecteren welke sub-gebeurtenissen moeten worden geplaatst in de pipe.

EIND WAARDE

       Bij  succes  wordt  nul  teruggegeven.  Bij  falen  wordt  -1  teruggegeven,  wordt  errno
       overeenkomstig gezet, en pipefd blijft ongewijzigd.

       Op Linux (en andere systemen), verandert pipe() de pipefd niet na een fout. Een eis om dit
       gedrag te standaardiseren werd toegevoegd in POSIX.1-2008 TC2. De Linux-specifieke pipe2()
       systeem aanroep doet hetzelfde en verandert pipefd niet bij een fout.

FOUTEN

       EFAULT pipe_bes_ind is ongeldig.

       EINVAL (pipe2()) Ongeldige waarde in vlaggen.

       EMFILE De per-proces limiet van het aantal open bestandsbeschrijvingen werd bereikt.

       ENFILE De grens aan het aantal open bestanden van het systeem is bereikt.

       ENFILE De harde grens van gebruikers geheugen dat kan worden toegewezen  aan  pijpen  werd
              bereikt en de aanroeper was niet gerechtigd; zie pipe(7).

       ENOPKG (pipe2())   O_NOTIFICATION_PIPE  werd  doorgegeven  in  flags en ondersteuning voor
              informaties (CONFIG_WATCH_QUEUE)  is niet gecompileerd in de kernel.

VERSIES

       pipe2() werd toegevoegd aan Linux 2.6.27; glibc ondersteuning is beschikbaar  vanaf  glibc
       2.9.

VOLDOET AAN

       pipe(): POSIX.1-2001, POSIX.1-2008.

       pipe2() is Linux-specifiek.

OPMERKINGEN

       De  Systeem V ABI op sommige architecturen staat toe om meer dan een register te gebruiken
       om meerdere waarden terug te geven; verschillende architecturen

       (namelijk Alpha, IA-64, MIPS, SuperH en SPARC/SPARC64) (mis)/(ge)bruiken  deze  eigenschap
       om  de  pipe()  systeem  aanroep  in  een  functionele manier te implementeren: de aanroep
       gebruikt geen argumenten en geeft een paar bestandsbeschrijvingen  terug  bij  succes.  De
       glibc  pipe()  omwikkel functie handelt dit transparant af. Zie syscall(2) voor informatie
       betreffende registers die gebruikt worden om de tweede bestandsbeschrijving op te slaan.

VOORBEELDEN

       Het volgende programma maakt een pijp aan, vervolgens wordt fork(2) gebruikt om  een  kind
       proces  aan  te  maken;  dit  kind  erft  een  dubbele set bestandsbeschrijvingen die naar
       dezelfde pijp wijzen. Na de fork(2) sluit elk proces de bestandsbeschrijving die het  niet
       nodig heeft voor de pijp (zie pipe(7)). Het ouder proces schrijft vervolgens de tekenreeks
       bevat in de commando regel van het  programma  naar  de  pijp,  en  het  kind  leest  deze
       tekenreeks byte voor byte van de pijp en echo´ed deze naar de standaard uitvoer.

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

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

           if (argc != 2) {
               fprintf(stderr, "Usage: %s <string>\n", argv[0]);
               exit(EXIT_FAILURE);
           }

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

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

           if (cpid == 0) {    /* kind leest van de pijp */
               close(pipefd[1]);          /* Sluit het ongebruikte schrijf-einde */

               while (read(pipefd[0], &buf, 1) > 0)
                   write(STDOUT_FILENO, &buf, 1);

               write(STDOUT_FILENO, "\n", 1);
               close(pipefd[0]);
               _exit(EXIT_SUCCESS);

           } else {            /* Ouder schrijft argv[1] naar de pijp */
               close(pipefd[0]);          /* Sluit ongebruikt lees-einde */
               write(pipefd[1], argv[1], strlen(argv[1]));
               close(pipefd[1]);          /* Lezer zal EOF zien */
               wait(NULL);                /* Wacht op het kind */
               exit(EXIT_SUCCESS);
           }
       }

ZIE OOK

       fork(2),  read(2),  socketpair(2),  splice(2),  tee(2),  vmsplice(2),  write(2), popen(3),
       pipe(7)

VERTALING

       De  Nederlandse  vertaling  van  deze  handleiding  is  geschreven   door   Jos   Boersema
       <joshb@xs4all.nl>,  Mario  Blättermann  <mario.blaettermann@gmail.com>  en  Luc Castermans
       <luc.castermans@gmail.com>

       Deze vertaling is vrije documentatie;  lees  de  GNU  General  Public  License  Version  3
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  of later over de Copyright-voorwaarden. Er is
       geen AANSPRAKELIJKHEID.

       Indien U fouten in de vertaling van deze handleiding zou vinden,  stuur  een  e-mail  naar
       ⟨debian-l10n-dutch@lists.debian.org⟩.