linux - pipe - čudno obnašanje

Naj samo še povem takaj imam

"while read juhu; do xxd -ps <<<"$juhu"; done"

. Zato, ker če uporabim samo "xxd -ps", mi spet nič ne izpiše. Tud to ne štekam zakaj...

Mislim da ni to. Problem v tem znaku #. Mislim da je problem v xxd (oz. od ima enak efekt). Če imam com port linije sklenjene (se pravi kar pošljem dobim tudi nazaj na vhod), in pošiljam na izhod:

echo "123456" > /dev/ttyUSB0

dobim v različnih primerih različne rezultate. Enostavno ne razumem zakaj mi v četrtem primeru nič ne izpiše. Kot da ta xxd (od) ne bi imel za izhod "standard output" (je to možno?)

1: laptop:~$ cat /dev/ttyUSB0
123456
123456
123456
^C
2: laptop:~$ cat /dev/ttyUSB0 | cat
123456
123456
123456
^C
3: laptop:~$ xxd -p /dev/ttyUSB0
3132333435360a3132333435360a3132333435360a^C
4: klemen@klemen-laptop:~$ xxd -p /dev/ttyUSB0 | cat
^C

Tako enostaven primer - kar dobim na vhod bi rad pretvoril v hex in preusmeril naprej - pa se že dva dni zaje..a.a... to je kr nekej...
A se da na "nižjem nivoju" pogledat, kaj vrže ven v enem in drugem primeru, oz kaj je problem da ne dela... kako naj to debugiram?

Aja, pa spet, če uporabim echo, pa dela vse kot je treba, tudi z xxd.

laptop:~$ echo "123456" | xxd -p | cat
3132333435360a

A je lahko to komu jasno

A se da na "nižjem nivoju" pogledat, kaj vrže ven v enem in drugem primeru, oz kaj je problem da ne dela... kako naj to debugiram?

UTSL

Sej biffer flushne, poglej zadnji primer echo "123456" | xxd -p | cat

Sej program v c-ju sem imel na 3/4 napisan, ampak se je potem ustavilo pri pipah, ker še nikoli delal z njimi, zato sem se potem odločil uporabit obstoječe stvari.

Naj ti bo. V resnici že xxd bufferira svoj output.

Sej biffer flushne, poglej zadnji primer echo "123456" | xxd -p | cat

Tukaj stvar seveda dela, saj xxd flushne output takoj, ko najde na svojem vhodu EOF. Takrat seveda izvede tudi exit().

V primeru, ko pa se na vhodu ne pojavi EOF (in to je seveda tudi v primeru tvojega branja s tty device-a), xxd flushne šele takrat, ko je njegov izhodni buffer poln.

Za demonstracijo sem ti spisal programček myecho.c:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
        int ntimes = -1;
        int i;

        if (argc == 2) {
                ntimes = atoi(argv[1]);
        }


        if (ntimes == -1) {
                while (1) {
                        printf("123456\n");
                        sleep(1);
                }
        } else {
                for (i = 0; i < ntimes; ++i) {
                        printf("123456\n");
                        sleep(1);
                }
        }

        return 0;
}

V konzoli poženi sledeče in opiši, kaj vidiš:
a) ./myecho 5 | xxd -p
b) ./myecho | xxd -p

Ne, ne, ne in ne.

xxd bi moral nekako prisiliti, da po vsaki vrstici izvede flush. Catch je v tem, da se io streami v primeru, ko je standardni izhod ali vhod povezan na interaktivno napravo (tipkovnica, konzola, ...), obnašajo drugače, kot pa če je povezava preusmerjena v drug proces. Tako npr. C-jevska printf() funkcija po znaku za newline izvede flush le v primeru, ko je stdout usmerjen na konzolo. Če pa je stdout preusmerjen v datoteko ali na stdin drugega procesa, potem se ta flush ne izvede implicitno.

Sem malenkost spremenil programček:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>

int main(int argc, char *argv[]) {
        bool doflush = false;

        if (argc == 2 && strcmp(argv[1],"-f") == 0) {
                doflush = true;
        }

        while (1) {
                printf("123456\n");
                if (doflush) {
                        fflush(stdout);
                }
                sleep(1);
        }

        return 0;
}

Poženi:
a) ./myecho | xxd -p
b) ./myecho -f | xxd -p
in poročaj, kaj opaziš.

Namesto xxd programa lahko uporabiš tudi spodnjo kodo, ki jo lahko prilagodiš svojim potrebam.

myxxd.c:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>

int main() {
        char *line = NULL;
        size_t len = 0;
        ssize_t read;
        int i;

        while ((read = getline(&line, &len, stdin)) != -1) {
                for (i = 0; i < read; ++i) {
                        printf("%02x", line[i]);
                }
                printf("\n");
        }

        free(line);
        exit(EXIT_SUCCESS);
}

P.S. Za bolše razumevanje si preberi odgovore na stackoverflow

Evo zadnji rezultati:

laptop:~/vcd$ echo "123456" | ./myxxd | gawk '{printf"izhod: %s\n",$1}'
izhod: 3132333435360a

vse kul...

preko com porta:

laptop:~/vcd$ cat /dev/ttyUSB0  | ./myxxd 
3132333435360a

tud vse kul...

laptop:~/vcd$ cat /dev/ttyUSB0 | ./myxxd | gawk '{printf"izhod: %s\n",$1}'
^C

nič ne pride ven...

laptop:~/vcd$ cat /dev/ttyUSB0 | ./myxxd | gawk '{printf"izhod: %s\n",$1}'

Seveda ne dela, saj myxxd spet bufferira svoj output (ker njegov izhod ne konča v terminalu pač pa je preusmerjen na gawk-ov standardni vhod). Sedaj bi moral to že vedeti. Če želiš, da boš dobil izpis po vsakem newline, moraš stream flushniti (v myxxd.c dodaj klic fflush(stdout) na pravo mesto). Prav tako uporaba gawk-a sploh ni potrebna, saj lahko izpis formatiraš že v C kodi myxxd.c, ki jo lahko seveda drugače oz. ustrezneje poimenuješ.

A da uporabljaš pipe | ni potrebno uporabljati popen, write, read? Kdaj pa se potem to uporablja?

Ne, ker za to poskrbi lupina (bash, csh, zsh, ...). Popen() in kolegice uporabljaš takrat, ko se želiš iti medprocesne komunikacije v lastnoročno napisani C-jevski kodi. Za več uporabi man in google.