1. jedná se o velmi široce podporované rozšíření a není jednoduché nalézt POSIX-kompatibilní operační systém, který by je neposkytoval,
2. definice funkcí err, errx, warn a warnx, které budeme v tomto předmětu používat, se vejdou na cca 50 řádků, takže v případě potřeby je není problém do programů doplnit (zajímají-li Vás možné definice, naleznete je v poslední ukázce této kapitoly).

#include <err.h>        /* err, errx, warn, warnx */ 
#include <stdio.h>      /* dprintf */
#include <unistd.h>     /* STDOUT_FILENO */

1. jméno programu (toto je užitečné zejména ve chvíli, kdy uživatel spustil několik programů najednou, třeba spojených rourou)
2. popis poslední systémové chyby – výčet možných chyb naleznete např. v manuálové stránce man 7p errno.

    return 0; 
}

1. nedošlo k úniku zdrojů, tzn. každý zdroj, který podprogram vyžádal, musí být vrácen, nebo se musí stát součástí stavu programu (a tedy bude vrácen později, v rámci standardního – nechybového – úklidu),
2. byly zachovány veškeré požadované invarianty, na které mohl mít podprogram vliv – v ideálním případě je chování podprogramu „všechno anebo nic“, tzn. pokud podprogram neuspěl, nebude mít žádný pozorovatelný efekt,⁷
3. volající byl o tomto selhání co možná nejpodrobněji informován.

#define _POSIX_C_SOURCE 200809L 
#include <unistd.h>     /* read, write */
#include <fcntl.h>      /* openat */
#include <err.h>        /* warn */
#include <errno.h>      /* errno */

1. systémové volání openat může selhat, například proto, že požadovaný soubor neexistuje, a s touto situací se budeme muset vypořádat,
2. je-li soubor úspěšně otevřen, popisovač souboru, který získáme jako návratovou hodnotu, reprezentuje zdroj který je nutné později opět uvolnit (systémovým voláním close).

    fd_in = openat( from_dir, from_name, O_RDONLY ); 

        if ( close( fd_in ) == -1 ) 
            warn( "failed to close file %s", from_name );

        errno = saved_errno; 
        return 1;
    }

    do { 
        bytes_read = read( fd_in, buffer, nbytes );

        if ( bytes_read == -1 ) 
        {

            if ( close( fd_in ) == -1 ) 
                warn( "failed to close file %s", from_name );
            if ( close( fd_out ) == -1 )
                warn( "failed to close file %s", to_name );

            errno = saved_errno; 
            return 2;
        }

        bytes_written = write( fd_out, buffer, bytes_read ); 

        if ( bytes_written == -1 ) 
        {

            if ( close( fd_in ) == -1 ) 
                warn( "failed to close file %s", from_name );
            if ( close( fd_out ) == -1 )
                warn( "failed to close file %s", to_name );

            errno = saved_errno; 
            return 2;
        }
    } while ( bytes_read != 0 );

    return 0; 
}

    if ( fd != -1 && close( fd ) == -1 ) 
        warn( "failed to close file %s", name );

    errno = saved_errno; 
}

    const int nbytes = 1024; 
    char buffer[ nbytes ];
    int bytes_read, bytes_written;

    if ( ( fd_in = openat( from_dir, from_name, O_RDONLY ) ) == -1 ) 
        goto error;

    if ( ( fd_out = openat( to_dir, to_name, O_WRONLY | O_CREAT, 
                            0666 ) ) == -1 )
        goto error;

    rv = 2; 

    do { 

        if ( ( bytes_read = read( fd_in, buffer, nbytes ) ) == -1 ) 
            goto error;

        if ( ( bytes_written = write( fd_out, buffer, 
                                      bytes_read ) ) == -1 )
            goto error;

    rv = 0; 

error: 
    close_or_warn( fd_in, from_name );
    close_or_warn( fd_out, to_name );
    return rv;
}

int main( void ) /* demo */ 
{
    int wd = openat( AT_FDCWD, ".", O_DIRECTORY );

    if ( wd == -1 ) 
        err( 1, "could not open working directory" );

    const char *src = "a0_intro.txt"; 
    const char *dest = "zt.intro.txt";

    if ( copy_1( wd, src, wd, dest ) != 0 ) 
        warn( "copying %s to %s failed", src, dest );

    if ( copy_2( wd, src, wd, dest ) != 0 ) 
        warn( "copying %s to %s failed", src, dest );

    if ( unlinkat( wd, dest, 0 ) != 0 ) 
        warn( "removing %s failed", dest );

    return 0; 
}

1. copy – čtení a zápis do obyčejného souboru,
2. filter – kopírujeme pouze některé záznamy,
3. hello – standardní vstup a výstup.

1. count – počítání zadaného bajtu na vstupu,
2. bwconv – převod obrázku ze stupňů šedi na černobílý,
3. catfd – použití read a write
4. pick – vykopíruje zadaný rozsah bajtů z každého záznamu,
5. align – zarovnaný zápis „zubaté“ matice,
6. split – rozdělení záznamů ze vstupu na dva výstupy.

1. min – výpis záznamu s nejmenším jednobajtovým klíčem,
2. bcount – počítání různých bajtů které se objeví na vstupu,
3. buniq – výpis každého bajtu nejvýše jednou,
4. otp – „one time pad“ na dvou vstupech,
5. grep – přepis záznamů, které obsahují zadanou hodnotu,
6. togray – † konverze barevného obrázku na černobílý.

• fd – popisovač, do kterého hodláme zapisovat,
• buf – ukazatel na paměť, kde jsou uložena data určená k zápisu,
• nbytes – počet bajtů, které si přejeme zapsat.

• -1 značí chybu zápisu,
• kladné číslo menší než nbytes – pro kompletní zápis nebyl dostatek místa a další volání write selže s výsledkem -1,
• přesně nbytes – zápis proběhl bez problémů,
• konečně 0 může nastat pouze pro nulové nbytes.

• memcpy
• memcmp
• memchr

#include <unistd.h>  /* read, write */ 
#include <fcntl.h>   /* openat */
#include <string.h>  /* memcmp */
#include <err.h>     /* err */

    int fd = openat( AT_FDCWD, filename, O_RDONLY ); 

1. Bajtů může být přečteno méně, než jsme žádali – kolik jich bylo skutečně přečteno zjistíme až z návratové hodnoty.
2. Vedlejším efektem volání read je, že do paměti určené adresou buffer bude zapsáno až nbytes bajtů (volání tedy přepíše hodnoty na adresách buffer + 0, buffer + 1, …, buffer + nbytes - 1). Abychom si omylem nezničili nějaká nesouvisející data, musíme systémovému volání read předat adresu, od které máme vyhrazeno alespoň nbytes bajtů.

    char buffer[ nbytes ]; 
    ssize_t bytes_read = read( fd, buffer, nbytes );

    if ( memcmp( buffer, "foo\n", expect ) ) 
        errx( 1, "file %s has unexpected content", filename );

• standardní vstup, na popisovači číslo 0, symbolicky STDIN_FILENO, který je implicitně „připojený ke klávesnici“ (čtením z tohoto popisovače získáme bajty, které uživatel zadal do terminálu po spuštění programu),
• standardní výstup, na popisovači číslo 1, symbolicky STDOUT_FILENO, který je implicitně „připojený k obrazovce“ (zápisem do tohoto popisovače zobrazujeme data na obrazovku terminálu),
• standardní chybový výstup, na popisovači číslo 2, symbolicky STDERR_FILENO, který je implicitně spojen s předchozím a tedy odesílán na obrazovku.

• užitný výstup, který je hlavním výsledkem výpočtu a tzv.
• diagnostický výstup, který obsahuje informace o průběhu výpočtu, zejména o chybách.

int main( void ) /* demo */ 
{

• 0 proběhlo-li vše v pořádku,
• 1 obsahuje-li soubor nekompletní řádek,
• 2 v případě selhání čtení nebo jiné systémové chyby (v tomto případě navíc není určeno, jaká hodnota bude zapsána do výstupního parametru count).

int count_lines( int fd, int *count ); 

• fd_in – popisovač pro vstupní bitmapová data;
• w – šířka obrázku;
• h – výška obrázku;
• fd_out – výstupní popisovač;
• threshold – mez rozdělující bílou a černou (hodnota 0–255).

• fds – ukazatel na pole popisovačů,
• count – počet popisovačů zde uložený,
• out_fd – výstupní popisovač.

• Hodnoty jsou ukládány oddělené znakem čárky , – U+002C.
• Počet hodnot na každém řádku odpovídá počtu sloupců. Všechny řádky tak musí obsahovat stejný počet hodnot, jinak by se nejednalo o validní tabulku.
• Každý řádek je zakončen znakem \n (U+000A, označovaný line feed nebo též newline).

• fd – výstupní popisovač, na který má být zapsána vpravo zarovnaná tabulka;
• values – ukazatel na pole celočíselných hodnot o velikosti alespoň cols × rows;
• cols – počet sloupců;
• rows – počet řádků.

• dir_fd – popisovač adresáře, ve kterém bude hledat všechny níže zmíněné soubory,
• list – jméno souboru se jmény souborů ke čtení,
• out_fd – výstupní popisovač.

• 0 – čtení úspěšné a soubor je validní;
• 1 – čtení úspěšné, ale robot se posunul o více pozic;
• 2 – čtení úspěšné, ale soubor je špatného formátu;
• 3 – čtení neúspěšné.

int path( const char* file, int len ); 

int linked( const char* file, int out ); 

‹obsah prvního souboru XOR obsah druhého souboru›.

• jedná se o objekt operačního systému, který má identitu, a na který se může odkazovat popisovač otevřeného souboru,
• ze socketu můžeme číst data (bajty), a/nebo do něj data zapisovat.

1. xxx
2. xxx

1. min – velmi jednoduchý datagramový „server“,
2. plog – ukládání datagramů do souboru,
3. otpd – šifrování datagramů (keystream ze souboru),
4. newsc – jednoduchý klient pro stažení novinek,
5. newsd – server pro předchozí,
6. tftpw – odeslání souboru – první interaktivní protokol.

1. agree – domluvení společné podmnožiny
2. xxx
3. filter – dva sockety, přeposílá obousměrně podle podmínky
4. xxx
5. xxx
6. tftpr – RRQ, uloží data do souboru

1. není potřeba (ani není možné) navazovat spojení – s tím je spojena i větší symetrie mezi komunikujícími stranami, např. v tom, že obě strany musí mít reprezentovatelnou adresu,
2. datagram je doručen vždy jako celek,²⁰ a to i na úrovni volání sendto/recvfrom – není tedy potřeba řešit situace, kdy read skončí „uprostřed věci“ a my musíme data skládat na straně programu.

    snprintf( sa->sun_path, sizeof sa->sun_path, "%s", path ); 
}

void bind_unix( int sock_fd, const char *addr ) 
{
    struct sockaddr_un sa = { .sun_family = AF_UNIX };

    setup_unix( &sa, addr ); 

    if ( unlink( sa.sun_path ) == -1 && errno != ENOENT ) 
        err( 1, "unlinking %s", sa.sun_path );

    if ( bind( sock_fd, ( struct sockaddr * ) &sa, sizeof sa ) ) 
        err( 1, "binding a unix socket to %s", sa.sun_path );
}

    char buffer[ 512 ]; 
    int bytes_recvd;

    if ( ( bytes_recvd = recvfrom( sock_fd, buffer, 512, 0, 
                                   sa, &sa_size ) ) == -1 )
        err( 1, "recvfrom on %s", addr );

    if ( sendto( sock_fd, "pong", 4, 0, sa, sa_size ) == -1 ) 
        err( 1, "sending pong on %s", sun.sun_path );

} 

    struct sockaddr_un sun_dest = { .sun_family = AF_UNIX }; 
    struct sockaddr *sa_dest = ( struct sockaddr * ) &sun_dest;
    socklen_t sa_size = sizeof sun_dest;

    setup_unix( &sun_dest, addr_dest ); 

• implicitní cílovou adresu, kterou použije pro volání send (u kterého, na rozdíl od sendto, adresu uvést nemůžeme) – tuto adresu můžeme vždy „přebít“ použitím volání sendto,
• adresu, ze které hodláme zprávy přijímat – operační systém bude zprávy od jiných odesílatelů odmítat.

    if ( ( bytes_recvd = recv( sock_fd, buffer, 512, 0 ) ) == -1 ) 
        err( 1, "recv on %s", addr_us );

int main( int argc, const char **argv ) 
{
    if ( argc != 3 && argc != 4 )
        errx( 0, "expected arguments: <send|recv> recv_socket [send_socket]" );

    if ( sock_fd == -1 ) 
        err( 1, "creating a unix socket" );

        sender( sock_fd, argv[ 2 ], argv[ 3 ] ); 
    }
    else
        errx( 1, "expected 'send' or 'recv' as first argument" );

    return 0; 
}

• 0 je-li ověření úspěšné,
• 1 je-li zjištěno, že server se nechová korektně,
• 2 dojde-li k systémové chybě.

int check_echo( const char* sock_path, const char* msg, int size ); 

• addr – adresa unixového socketu na které běží server,
• sender – nulou ukončený řetězec, který obsahuje adresu odesílatele,
• recip – podobně, ale s adresou adresáta,
• data – obsah zprávy (včetně hlaviček; nebude obsahovat řádek se samostatně stojící tečkou).

• 0 – vše proběhlo v pořádku a mail byl doručen,
• 1 – adresát neexistuje,
• 2 – došlo k jiné chybě doručení,
• -1 – došlo k systémové chybě na straně klienta.²³

• LHLO jméno – pozdrav; jako jméno použijte pb152cv,
• MAIL FROM:<adresa> – oznámí serveru, že hodláme odesílat mail a zároveň adresu jeho odesílatele,
• RCPT TO:<adresa> – předá serveru adresu, na kterou má zprávu doručit (lze použít vícekrát, ale my budeme odesílat zprávy vždy pouze jednomu adresátovi),
• DATA – iniciuje přenos samotné zprávy, která je ukončena řádkem, který obsahuje pouze tečku,
• QUIT – ukončí sezení, server příkaz potvrdí a uzavře spojení.

• addr – adresa unixového socketu na které běží server,
• name – nulou ukončený název souboru,
• data – ukazatel na data souboru, který má být uložen,
• size – velikost souboru.

1. klient odešle paket WRQ, který obsahuje:

◦ kód příkazu – bajty ‹0x00 0x02›,
◦ název souboru ukončený nulovým bajtem,
◦ řetězec ‹"octet"›, ukončen dalším nulovým bajtem,

2. server odpoví paketem ACK nebo ERROR (viz níže),
3. je-li odpověď ACK, klient pokračuje odesláním paketu typu DATA, který obsahuje:
   • kód příkazu – bajty 0x00 0x03,
   • dvoubajtové sekvenční číslo (první DATA paket má číslo 1, každý další pak o jedna větší než předchozí),
   • 0–512 bajtů dat (každý paket krom posledního má 512 bajtů dat, poslední paket zbytek – může být i nula),

4. server potvrdí příjem datového paketu opět paketem ACK, který zároveň slouží jako výzva k odeslání dalšího datového paketu,
5. odpověď ACK na poslední DATA paket signalizuje, že přenos skončil a klient může spojení uzavřít.

• ACK – začíná bajty 0x00 0x04, další dva bajty určují pořadové číslo paketu, na který navazují (0 pro paket WRQ, 1 a výše pro pakety DATA),
• ERROR – začíná bajty 0x00 0x05, dále dvoubajtový kód chyby, řetězec popisující chybu a nulový bajt.

• 0 – přenos byl úspěšný,
• kladné číslo – přenos skončil chybou na straně serveru, návratový kód odpovídá kódu chyby z paketu ERROR,
• -3 – server ukončil přenos s chybou 0 (paketem ERROR),
• -2 – neočekávaný paket od serveru (špatný kód příkazu, špatné sekvenční číslo v paketu typu ACK, špatná velikost paketu),
• -1 – nastala systémová chyba na straně klienta.

int tfpt_put( const char *addr, const char *name, 
              const void *data, size_t size );

• state_fd – popisovač souboru, který obsahuje již známá data, a do kterého budou nová data připsána, tzn. po ukončení news_update bude soubor obsahovat přesnou kopii dat ze serveru,
• addr – adresa unixového socketu, na které server poslouchá.

./p5_echod cesta_k_socketu

• sock_fd, popisovač datagramového socketu,
• our_set, ukazatel na pole, které popisuje podmnožinu množiny , a to tak, že číslo je přítomno právě když je v poli nastavený -tý bit,²⁵
• intersection – ukazatel na neinicializované pole stejné velikosti a stejného významu, do kterého uloží výsledek.

• -3 v případě, že se domluva nezdařila – klient vybranou množinu zamítl,
• -2 při chybě protokolu (klient poslal data v nečekaném tvaru),
• -1 v případě, že nastala systémová chyba na straně serveru,
• konečně 0 byla-li podmnožina úspěšně domluvena, pak zároveň do intersection tuto uloží (v žádném jiném případě hodnoty v intersection měnit nebude).

int agree( int sock_fd, const char our_set[ 64 ], 
                        char intersection[ 64 ] );

• fd_in, popisovač datagramového socketu, na kterém bude očekávat příchozí pakety,
• fd_out na který bude některé pakety přeposílat – tento socket má nastavenu implicitní adresu (je „připojený“),
• offset – pořadové číslo 32bitového slova, které budeme kontrolovat,
• threshold – 32bitové číslo bez znaménka, které určí, zda se má daný datagram přeposlat nebo zahodit.

1. neobsahuje-li datagram celé 32bitové slovo, které by začínalo na indexu offset, datagram je zamítnut (zahozen),
2. je-li slovo přítomno a jeho hodnota je alespoň threshold, datagram je přeposlán.

• -2 server ohlásil chybu,
• -1 nastala systémová chyba na straně klientu,
• 0 soubor byl úspěšně převzat a uložen.

int tftp_get( const unsigned char *id, int id_len, 
              int sock_fd, int out_fd );

1. count – počítání přijatých bajtů
2. poll – souběžná komunikace na dvou popisovačích

1. min – jednoduchý datagramový server,
2. read – read loop pro pevně velký záznam
3. ready – nalezení popisovače připraveného ke čtení
4. collect – čtení dat ze skupiny popisovačů
5. fget – blokový protokol (posílá bloky, čte potvrzení)
6. fput – podobně, ale přijímá bloky, posílá potvrzení

• memmove

        total += bytes_read; 
    }
}

static void close_or_warn( int fd, const char *name ) 
{
    if ( close( fd ) == -1 )
        warn( "closing %s", name );
}

int main( void ) /* demo */ 
{
    int fds[ 2 ];
    int bytes, status;

    if ( pid == -1 ) 
        err( 1, "fork" );

        if ( write( fds[ 0 ], "hel", 3 ) == -1 || 
             write( fds[ 0 ], "lo ", 3 ) == -1 ||
             write( fds[ 0 ], "world", 5 ) == -1 )
        {
            err( 1, "writing to the socket" );
        }

        close_or_warn( fds[ 0 ], "sender side of a socketpair" ); 
        return 0;
    }

    close_or_warn( fds[ 0 ], "sender side of a socketpair" ); 

    assert( WIFEXITED( status ) ); 
    assert( WEXITSTATUS( status ) == 0 );

    close_or_warn( fds[ 1 ], "receiver side of a socketpair" ); 

    return 0; 
}

void pong( int fd_1, int fd_2 ) 
{

    } 
}

void recv_and_reply( int fd ) 
{

    if ( bytes == -1 ) 
        err( 1, "recv" );

} 

static void close_or_warn( int fd, const char *name ) 
{
    if ( close( fd ) == -1 )
        warn( "closing %s", name );
}

int main( void ) /* demo */ 
{
    int fds_1[ 2 ], fds_2[ 2 ];

    if ( socketpair( AF_UNIX, SOCK_DGRAM, 0, fds_1 ) == -1 || 
         socketpair( AF_UNIX, SOCK_DGRAM, 0, fds_2 ) == -1 )
    {
        err( 1, "socketpair" );
    }

    if ( pid == -1 ) 
        err( 1, "fork" );

    if ( pid == 0 ) /* child */ 
    {
        close_or_warn( fds_1[ 1 ], "client side of a socketpair" );
        close_or_warn( fds_2[ 1 ], "client side of a socketpair" );
        pong( fds_1[ 0 ], fds_2[ 0 ] );
        exit( 1 ); /* should never return */
    }

    close_or_warn( fds_1[ 0 ], "server side of a socketpair" ); 
    close_or_warn( fds_2[ 0 ], "server side of a socketpair" );

    int fd_1 = fds_1[ 1 ], 
        fd_2 = fds_2[ 1 ];

    uint32_t reply_1, reply_2; 

    if ( recv( fd_2, &reply_2, 4, 0 ) == -1 ) 
        err( 1, "recv on fd_2" );
    if ( recv( fd_1, &reply_1, 4, 0 ) == -1 )
        err( 1, "recv on fd_1" );

    assert( ntohl( reply_1 ) == 5 ); 
    assert( ntohl( reply_2 ) == 3 );

    int status; 

    if ( kill( pid, SIGTERM ) == -1 || 
         waitpid( pid, &status, 0 ) == -1 )
        err( 1, "terminating child process" );

    assert( WIFSIGNALED( status ) ); 
    assert( WTERMSIG( status ) == SIGTERM );

    close_or_warn( fd_1, "client side of a socketpair" ); 
    close_or_warn( fd_2, "client side of a socketpair" );

    return 0; 
}

• bits je ukazatel na bitové pole,
• count je velikost takto předaného pole v bitech.

• bajt s nejnižší adresou odpovídá popisovačům 0–7,
• následující bajt popisovače 8–15, atd.,
• uvnitř každého bajtu odpovídá nejméně významný bit popisovači s nejnižším číslem.

• count – počet popisovačů, se kterými bude pracovat,
• fds – ukazatel na pole popisovačů,
• buffers – ukazatel na pole ukazatelů, kde každý ukazatel určuje paměť, do které se načtou data z odpovídajícího popisovače,
• sizes – ukazatel na pole čísel, které určí, kolik nejvýše bajtů se má z odpovídajícího popisovače načíst,
• pivot – index popisovače (význam viz níže).

• načte data z jednoho popisovače,
• posune odpovídající ukazatel v poli buffers za konec právě načtených dat,
• sníží odpovídající hodnotu v poli sizes o počet načtených bajtů,
• vrátí index dotčeného popisovače.

• pošle další blok, je-li nějaký k dispozici,
• jinak zavře spojení.

• 0 v případě úspěchu (všechna data, která server odeslal, byla uložena),
• -2 v případě, že byla komunikace ukončena kvůli selhání zápisu dat do souboru a
• -1 v případě, že nastala chyba komunikace.

• 0 v případě úspěchu – server potvrdil všechny zprávy a soubor s daty k odeslání je prázdný,
• -3 je-li předán nesprávný datový soubor,
• -2 v případě, že byla komunikace ukončena kvůli selhání na straně serveru (server indikoval, že data nebyl schopen uložit),
• -1 v případě, že nastala chyba komunikace nebo systémová chyba na straně klienta.

• in_fd – popisovač, ze kterého bude data číst,
• out_fd – popisovač, do kterého bude data přeposílat,
• log_fd – popisovač souboru, ve kterém bude udržovat záznamy,
• limit – limit na počet bajtů uložených v souboru log_fd.

• zpráva, která začíná nulovým bajtem, obsahuje pouze jeden další bajt, který označuje nenulový kód kategorie – jedná se o „subscribe“ část protokolu, tzn. odesílatel této zprávy si přeje dostávat zprávy z dané kategorie,
• ve zprávě, která začíná nenulovým bajtem, tento označuje kód kategorie; tato zpráva dále obsahuje bajt, který značí jak dlouhý je zbytek zprávy – tento typ zprávy tvoří „publish“ část.

1. sum – sumarizace tabulky s pevně velkými záznamy
2. list – kontrola struktury záznamů
3. flood – in-situ flood fill v bitmapovém souboru
4. write – zápis bloku dat do neblokujícího popisovače
5. hose – souběžný zápis do několika popisovačů
6. tee ‡ – souběžný zápis s vyrovnávací pamětí

• mmap vytvoří mapování – vstupem je popisovač obyčejného souboru, vlastnosti mapování (přístupová práva, sdílený vs soukromý přístup) a jeho rozsah,
• msync vyžádá zápis změn, které program provedl v mapované paměti, zpátky do souboru na disku, a konečně
• munmap již nepotřebné mapování uvolní a zároveň provede případné nedokončené zápisy do souboru.

• sdílené (MAP_SHARED) – změny provedené skrz toto mapování se projeví v souboru, do kterého takto mapované adresy odkazují,
• soukromé (MAP_PRIVATE) – změny provedené v mapované paměti zůstávají viditelné pouze v procesu, který mapování vlastní.

1. každý zdroj, který byl vyžádán (alokován), musí být také vrácen (uvolněn),
2. odpovědnost za vrácení zdroje musí být jasně určena,
3. obě pravidla platí i v situaci, kdy nějaká operace selže.

• O_NONBLOCK

    for ( node = ht->buckets[ hash ]; node != NULL ; node = node->next ) 
        if ( node->value == value )
            break;

    if ( !node ) 
    {
        if ( !( node = malloc( sizeof( struct hash_node ) ) ) )
            return NULL;
        node->next = ht->buckets[ hash ];
        node->value = value;
        node->counter = 0;
        ht->buckets[ hash ] = node;
    }

    return node; 
}

    for ( int i = 0; i < 65536; ++i ) 
        for ( n = ht->buckets[ i ]; n != NULL; n = next )
        {
            next = n->next;
            free( n );
        }
}

• popisovač vstupního souboru,
• počet čtyřbajtových slov v jednom záznamu record_size,
• pořadové číslo čtyřbajtového slova v záznamu, které budeme zpracovávat value_index,
• výstupní parametr result.

    if ( size == -1 || size % record_size != 0 ) 
        return -1;

• velikost mapování (v tomto případě velikost souboru),
• přístupový mód (v tomto případě „pouze pro čtení“),
• režim sdílení (MAP_PRIVATE protože do souboru nehodláme zapisovat),
• popisovač souboru, kterého obsah chceme do paměti mapovat,
• místo, od kterého chceme obsah souboru mapovat (v bajtech, v tomto případě mapujeme celý soubor od prvního bajtu).

    uint32_t *base = mmap( NULL, size, PROT_READ, MAP_PRIVATE, fd, 0 ); 
    int retcode = -1;

    for ( ssize_t offset = 0; offset < size / 4; offset += record_size ) 
    {
        uint32_t value = ntohl( base[ offset + value_index ] );
        if ( !( node = hash_get( &ht, value ) ) )
            goto out;
        node->counter ++;
    }

    for ( int i = 0; i < 65536; ++i ) 
        for ( node = ht.buckets[ i ]; node != NULL; node = node->next )
            if ( node->counter > max ||
                 ( node->counter == max && node->value < *result ) )
            {
                *result = node->value;
                max = node->counter;
            }

    retcode = 0; 
out:

int main() /* demo */ 
{
    const char *name = "zt.d1_data.bin";
    int fd = open( name, O_CREAT | O_TRUNC | O_RDWR, 0666 );

    if ( fd == -1 ) 
        err( 1, "creating file %s", name );

    uint32_t buffer[ 65536 ]; 

    for ( int i = 0; i < 65536 ; ++i ) 
        switch ( i % 32 )
        {
            case 0: buffer[ i ] = htonl( 7 ); break;
            case 1: buffer[ i ] = htonl( 1 + ( ( i - 1 ) % 64 == 0 ) ); break;
            default: buffer[ i ] = i;
        }

    for ( int i = 0; i < 256; ++i ) 
        if ( write( fd, buffer, sizeof buffer ) == -1 )
            err( 1, "writing data into %s", name );

    uint32_t result; 

    assert( mode( fd, 8, 0, &result ) == 0 ); 
    assert( result == 7 );
    assert( mode( fd, 8, 1, &result ) == 0 );
    assert( result == 1 );

    if ( close( fd ) == -1 ) 
        warn( "closing %s", name );

    return 0; 
}

    for ( ; i < count && last + i <= max; ++i ) 
        buffer[ i ] = htonl( last + i );

    return i * 4; 
}

int iota_write( struct iota_state *state, 
                int buf_size, uint32_t max );

    for ( int i = 0; i < 2; ++i ) 
    {
        state[ i ].offset = 0;
        state[ i ].nbytes = iota_update( state[ i ].buffer, 64, max );
        pfds[ i ].events = POLLOUT;
    }

        if ( poll( pfds, 2, -1 ) == -1 ) 
            return -1;

        for ( int i = 0; i < 2; ++i ) 
            if ( pfds[ i ].revents & POLLOUT )
                if ( iota_write( state + i, 64, max ) == -1 )
                    return -1;
    }

    return 0; 
}

int iota_write( struct iota_state *state, 
                int buf_size, uint32_t max )
{

    int written = write( state->fd, data + state->offset, 
                         state->nbytes );

    state->offset += written; 
    state->nbytes -= written;

    return 0; 
}

static void close_or_warn( int fd, const char *name ) 
{
    if ( close( fd ) == -1 )
        warn( "closing %s", name );
}

int main( void ) /* demo */ 
{
    int fds_1[ 2 ], fds_2[ 2 ];

    if ( socketpair( AF_UNIX, SOCK_STREAM, 0, fds_1 ) == -1 || 
         socketpair( AF_UNIX, SOCK_STREAM, 0, fds_2 ) == -1 )
    {
        err( 1, "socketpair" );
    }

    if ( pid == -1 ) 
        err( 1, "fork" );

    if ( pid == 0 ) /* child */ 
    {
        close_or_warn( fds_1[ 1 ], "consumer side of a socketpair" );
        close_or_warn( fds_2[ 1 ], "consumer side of a socketpair" );

        if ( iota_pipe( fds_1[ 0 ], fds_2[ 0 ], 1 << 22 ) == -1 ) 
            err( 1, "iota_pipe unexpectedly failed" );
        else
            exit( 0 ); /* success */
    }

    close_or_warn( fds_1[ 0 ], "producer side of a socketpair" ); 
    close_or_warn( fds_2[ 0 ], "producer side of a socketpair" );

    int fd_1 = fds_1[ 1 ], 
        fd_2 = fds_2[ 1 ];

    uint32_t reply_1, reply_2; 

        assert( read( fd_2, &reply_2, 4 ) == 4 ); 
        assert( ntohl( reply_2 ) == i );
    }

    for ( uint32_t i = ( 1 << 19 ) + 1; i <= 1 << 22; ++i ) 
    {
        assert( read( fd_1, &reply_1, 4 ) == 4 );
        assert( ntohl( reply_1 ) == i );
    }

    assert( read( fd_1, &reply_1, 4 ) == 0 ); 

    int status; 

    if ( waitpid( pid, &status, 0 ) == -1 ) 
        err( 1, "awaiting child process" );

    assert( WIFEXITED( status ) ); 
    assert( WEXITSTATUS( status ) == 0 );

    close_or_warn( fd_1, "consumer side of a socketpair" ); 
    close_or_warn( fd_2, "consumer side of a socketpair" );

    return 0; 
}

• fd – popisovač souboru, se kterým bude pracovat (můžete předpokládat, že objekt, se kterým je svázaný, lze mapovat do paměti),
• cols – počet sloupců zde uložené tabulky,
• sizes – pole čísel (pro každý sloupec jedno), které určuje kolik bitů daný sloupec obsahuje (1–64),
• results – pole cols 64bitových čísel, kam uloží součty jednotlivých sloupců.

• uložen v posledních 4 bajtech,
• formou celého čísla se znaménkem (v dvojkovém doplňkovém kódu, nejvýznamnější bajt první),
• které určuje o kolik bajtů dále od začátku soubor začíná odkazovaný záznam oproti tomu aktuálnímu.

• soubor neobsahuje nic než záznamy,
• každý záznam vyjma posledního odkazuje na začátek jiného záznamu,
• poslední záznam odkazuje sám na sebe (tj. odkaz je nulový),
• na první záznam žádný jiný neodkazuje,
• na každý další záznam existuje právě jeden odkaz.

• fd je popisovač souboru ve formátu BMP, se kterým bude pracovat (a který lze mapovat do paměti),
• offset index prvního pixelu v souboru,
• w, h je šířka a výška obrázku v pixelech,
• x, y jsou souřadnice pixelu, od kterého začne vyplňovat jednobarevnou plochu,
• color je barva, na kterou plochu přebarví.

• count – počet popisovačů, se kterými se bude pracovat,
• fds – ukazatel na pole popisovačů,⁴⁰
• buffers – ukazatel na pole ukazatelů, kde každý určuje data, která se mají zapsat do příslušného popisovače,
• sizes – ukazatel na pole čísel, která určují, kolik dat se má do kterého popisovače zapsat.

• 0 – veškeré požadované zápisy byly provedeny,
• kladné číslo – počet popisovačů, které nejsou připravené k zápisu, ale jsou pro ně přichystaná data,
• -1 – došlo k systémové chybě – opětovné volání se stejnými parametry se pokusí akci zopakovat.

int hose( int count, int* fds, char** buffers, int* sizes ); 

• tee_init obdrží pole popisovačů, do kterých si přejeme data kopírovat, a vrátí ukazatel handle (nebo nulový ukazatel v případě selhání),
• tee_write obdrží ukazatel handle, ukazatel na data a velikost dat, které si přejeme rozeslat,
• tee_fini zapíše všechna zbývající data a uvolní veškeré zdroje přidružené k předanému ukazateli handle.

• 0 – veškerá data byla odeslána všem příjemcům,
• kladné číslo – počet popisovačů, které jsou „pozadu“,
• -1 – nastala chyba, která znemožnila zpracování předaných dat (data lze bezpečně do tee_write předat znovu, aniž by hrozilo dvojité odeslání).

1. csv
2. merge
3. lmdb
4. httpc
5. httpd
6. logd

• obsahuje-li v sobě některá hodnota právě používaný oddělovač, musí být uzavřena v uvozovkách (jinak jsou uvozovky kolem hodnot volitelné),
• obsahuje-li hodnota uzavřená v uvozovkách znaky " nebo \, tyto musí být uvozeny znakem \,
• znak nového řádku v hodnotě nepřipouštíme,
• oddělovač, uvozovka, zpětné lomítko a znak nového řádku jsou každý kódovány jedním bajtem.

• používat zadaný oddělovač (může být jiný nebo stejný jako byl na vstupu),
• právě ty hodnoty, které obsahují nový oddělovač, uzavře do uvozovek.

int reformat_csv( int fd_in, char old_delim, 
                  char new_delim, int fd_out );

• vstupní soubory mají stejnou velikost záznamu,
• soubory mohou být mnohem větší, než je dostupná paměť,
• vstupy mohou být roury nebo jiné objekty, které neumožňují opakované čtení (podobně výstup),
• výstup nebude obsahovat dva záznamy se stejným klíčem, a to ani v situaci, kdy je obsahoval některý soubor na vstupu (použije se první záznam z prvního souboru, který ho obsahuje).

• [00] 64bitové pořadové číslo stránky v souboru,
• [08] nevyužité 16bitové číslo,⁴¹
• [0a] 16bitové pole příznaků,
• [0c] 16bitová celková velikost metadatové části,
• [0e] 16bitové číslo prvního bajtu datové části.

• [10] 32bitové identifikační číslo (vždy 0xbeefc0de),
• [14] 32 + 64 + 64 bitů, které přeskočíme,
• [28] 6 × 64 bitů metadat o prázdném místě,
• [58] informace o hlavním B+stromě:
  • [58] 32 nevyužitých bitů,
  • [5c] 16 bitů příznaků,
  • [5e] 16bitová hloubka stromu,
  • [60] 3 × 64 bitů statistických informací,
  • [78] 64bitový počet klíčů,
  • [80] číslo kořenové stránky,
• [88] číslo poslední stránky,
• [90] pořadové číslo transakce, která tuto stránku zapsala.⁴²

• 48bitové číslo stránky (uzlu), na kterou tento klíč odkazuje,
• 16bitová velikost klíče,
• samotný klíč.

• 32bitová velikost hodnoty náležící tomuto klíči,
• 16 bitů příznaků (uvažujeme nulové),
• 16bitová velikost klíče,
• samotný klíč,
• hodnota náležící klíči.

• pro práci s čísly pevné bitové šířky se budou hodit typy uint16_t, uint64_t, int16_t, atd., definované hlavičkou stdint.h,
• při testování se může hodit modul lmdb pro Python:
  • získáte jej příkazem pip install lmdb,
  • env = lmdb.open('test') vytvoříte prázdnou databázi,
  • txn = env.begin(write=True) otevřete transakci,
  • txn.put(b'key', b'value') vložíte dvojici klíč/hodnota,
  • txn.commit() transakci ukončíte,
  • datový soubor se bude jmenovat test/data.mdb.

1. řádek požadavku (resp. stavový řádek pro odpověď),
   • řádek požadavku má formu METODA cesta HTTP/1.0,
   • stavový řádek má formu HTTP/1.0 číselný_kód popis,
2. hlavičky – každé pole začíná jménem, následované dvojtečkou a textovou hodnotou, která pokračuje až do konce řádku,⁴⁶
3. tělo, oddělené od hlaviček prázdným řádkem.

struct http_header_list 
{
    struct http_header header;
    struct http_header_list *next;
};

struct http_request 
{
    enum http_method method;
    char *path;
    struct http_header_list *headers;
};

struct file_list 
{
    struct file file;
    struct file_list *next;
};

static void unlink_if_exists( const char* file ) 
{
    if ( unlink( file ) == -1 && errno != ENOENT )
        err( 2, "unlinking %s", file );
}

int main( int argc, const char **argv ) 
{
    if ( argc == 1 )
        return 0; /* no automated tests */

    if ( argc > 2 ) 
        errx( 1, "expected arguments: socket_path" );

    struct file_list hello, bye; 

    hello.file.path = "/hello.txt"; 
    hello.file.content_type = "text/plain";
    hello.file.data = "hello world\n";
    hello.file.data_size = strlen( hello.file.data );
    hello.next = &bye;

    bye.file.path = "/bye.txt"; 
    bye.file.content_type = "text/plain";
    bye.file.data = "bye world\n";
    bye.file.data_size = strlen( bye.file.data );
    bye.next = NULL;

    unlink_if_exists( argv[ 1 ] ); 
    httpd( argv[ 1 ], &hello );

    return 1; /* httpd should never return */ 
}

• ok, logging as id\n čím potvrdí, že požadavek přijal a je připraven zaznamenávat přijaté zprávy,
• nebo error <popis chyby>\n narazí-li na nějaký problém (např. se nepodařilo otevřít logovací soubor).

int main( int argc, const char **argv ) 
{
    if ( argc == 1 )
        return 0; /* no automated tests */

    if ( argc < 4 ) 
        errx( 1, "arguments expected: "
                 "socket_path main_log log_dir" );

    int log_fd, dir_fd; 
    const char *sock = argv[ 1 ],
               *log  = argv[ 2 ],
               *dir  = argv[ 3 ];

    if ( unlink( sock ) == -1 && errno != ENOENT ) 
        err( 1, "removing %s", sock );

    if ( mkdir( dir, 0777 ) == -1 && errno != EEXIST ) 
        err( 1, "creating directory %s", dir );

    if ( ( log_fd = open( log, 
                          O_CREAT | O_TRUNC | O_RDWR,
                          0666 ) ) == -1 )
        err( 1, "creating %s", log );

    if ( ( dir_fd = open( dir, O_DIRECTORY ) ) == -1 ) 
        err( 1, "opening %s", dir );

    logd( sock, log_fd, dir_fd ); 

    return 1; /* logd should never return */ 
}

1. strings – základy práce s řetězci a textem,
2. dirs – nalezení / otevření obyčejného souboru,
3. acrostic – řetězec prvních písmen každého řádku.

1. long – nalezení nejdelšího řádku,
2. read – čtení záznamů oddělených specifickým bajtem,
3. cat – načtení souboru se jmény souborů pro spojení,
4. kvsd – slovníkový server s úložištěm v souborovém systému,
5. kvchk – ověření přítomnosti klíče a asociované hodnoty,
6. kvget – dávkové stažení (linked list klíčů na vstupu).

1. int fd je již existující popisovač, který je svázán se složkou, vůči které budeme uvádět cestu – lze použít symbolickou hodnotu AT_FDCWD, která označuje tzv. pracovní složku,
2. const char *path je řetězec (ukončený nulou), který udává název, případně cestu (oddělovačem je znak /) k souboru, se kterým hodláme pracovat,
3. int flags je bitová kombinace příznaků – budou nás pro tuto chvíli zajímat symbolické hodnoty:
   • O_RDONLY, O_WRONLY a O_RDWR, které určí jaké operace plánujeme později se souborem provádět,
   • O_CREAT která nám umožní vytvořit nový obyčejný soubor,
4. int mode dodáváme pouze tehdy, když může operací vzniknout nový soubor (zejména obsahuje-li parametr flags příznak O_CREAT).

• malloc, realloc, free

1. každé písmeno¹ je kódováno nějakou posloupností bajtů, a fragment textu (tzv. řetězec) je v paměti uložen tak, že kódování jednotlivých znaků (písmen) jsou uložena za sebou (na postupně se zvyšujících adresách),
2. nulový bajt je vyhrazen pro speciální účely (pro řadu knihovních a systémových funkcí označuje konec řetězce, tzn. bajt uložený bezprostředně před nulovým bajtem je poslední bajt kódující daný řetězec),
3. vybranou množinu znaků, nazývanou Portable Character Set, musí být systém schopen kódovat, a to navíc tak, že každému znaku odpovídá jeden bajt (jedná se o většinu znaků obsažených v ASCII⁴⁸),
4. konkrétní číselné hodnoty, kterými jsou tyto znaky kódované, nejsou pevně určeny (s výjimkou nulového znaku, který musí být kódován nulovým bajtem), ale v praxi každý systém, který potkáte, bude používat kódování ASCII, a naprostá většina UTF-8 (které je nadmnožinou ASCII).

#define _POSIX_C_SOURCE 200809L 
#include <string.h>     /* strlen, strcmp */
#include <stdio.h>      /* dprintf, snprintf */
#include <unistd.h>     /* STDOUT_FILENO */
#include <assert.h>

int main( void ) /* demo */ 
{

    assert( strcmp( "věc",  thing_1 ) == 0 ); 
    assert( strcmp( "věc",  thing_2 ) != 0 );

    return 0; 

    // cflags: -Wno-format-truncation 
}

    if ( fd == -1 ) 
        err( 1, "error opening %s", path );

    return fd; 
}

void close_or_warn( int fd, const char *name ) 
{
    if ( close( fd ) == -1 )
        warn( "error closing descriptor %d for file %s", fd, name );
}

int main( int argc, const char **argv ) /* demo */ 
{

1. nemusíme složitě konstruovat cesty, které by k souborům vedly – něco jako top_path + "/00/" + name – zápis, který v jazyce C samozřejmě nemůžeme použít; navíc
2. takto sestavené cesty mohou v různých iteracích ukazovat na soubory v různých složkách – souborový systém je sdílený a každá operace je potenciálním hazardem souběhu.⁵³

    for ( int i = 0; filenames[ i ]; ++i ) 
    {
        const char *name = filenames[ i ];
        int file_fd = open_or_die( dir_fd, name, O_RDONLY );

        const int nbytes = 10; 
        char buffer[ nbytes ];

        int bytes_read = read( file_fd, buffer, nbytes ); 

        if ( bytes_read == -1 ) 
            err( 1, "error reading %d bytes from %s",
                 nbytes, name );

        close_or_warn( file_fd, name ); 
    }

char *read_until( int fd, char delimiter, 
                  struct shift_buffer *buf, int *length );

• dir_fd – popisovač adresáře, ve kterém bude hledat všechny níže zmíněné soubory,
• list_fd – popisovač, ze kterého podprogram cat přečte jména souborů,
• out_fd – výstupní popisovač.

• 0 – podařilo se otevřít, přečíst a zapsat všechny soubory,
• -1 – chyba čtení z popisovače list_fd, chyba zápisu do out_fd, nebo jiná fatální systémová chyba,
• -2 – vše proběhlo v pořádku, ale některé soubory byly přeskočeny, protože se je nepodařilo otevřít.

int cat( int dir_fd, int list_fd, int out_fd ); 

• 0 je-li vše v pořádku (hodnota odpovídá očekávání),
• -1 došlo-li k chybě komunikace nebo jiné fatální chybě,
• -2 nebyl-li požadovaný klíč na serveru přítomen,
• -2 jestli byla hodnota přijata, ale neodpovídá očekávání.

int kvchk( int server_fd, const char *key, int data_fd ); 

• 0 je-li vše v pořádku (všechny hodnoty byly staženy a úspěšně uloženy),
• -1 došlo-li k chybě komunikace, chybě při ukládání dat, nebo jiné fatální chybě,
• -2 nebyl-li některý požadovaný klíč na serveru přítomen (nepřítomnost klíče ale nebrání stažení všech ostatních).

int kvget( int server_fd, int dir_fd, struct key_list *keys ); 

1. klíč je unikátní jméno (řetězec, který neobsahuje nulový znak ani znak /),
2. hodnota je odkaz na soubor (i-uzel) libovolného typu (může být opět adresářem).

1. newest – nalezení nejnovějšího souboru v zadané složce,
2. depth – počítání maximální hloubky adresářové struktury,
3. refs – kolik odkazů na soubor je v zadaném stromě.

1. fcount – počítání obyčejných souborů v adresáři,
2. access – kontrola práv u souborů zadaných seznamem,
3. list – sestavení spojovaného seznamu názvů souborů,
4. archive – přesun starých souborů do archivní složky,
5. find – rekurzivní hledání podle jména,
6. du – využití místa složkou (bez tvrdých odkazů).

• O_DIRECTORY pro openat
• fstatat
• renameat
• dup

• strcmp
• fdopendir
• readdir
• rewinddir
• closedir

    int dup_fd = dup( dir_fd ); 

    if ( dup_fd == -1 ) 
        goto out;

    while ( ( ptr = readdir( dir ) ) ) 
    {

            if ( !newest_name ) 
                goto out;
        }
    }

    if ( dir ) 
        closedir( dir );
    else if ( dup_fd != -1 )
        close( dup_fd );

    return rv; 
}

int main( void ) /* demo */ 
{
    int cwd_fd = open( ".", O_DIRECTORY | O_RDONLY );

    if ( cwd_fd == -1 ) 
        err( 2, "opening working directory" );

    char *name = find_newest( cwd_fd ); 
    dprintf( STDOUT_FILENO, "the newest file is %s\n", name );
    free( name );
    return 0;
}

    if ( !dir ) 
        goto out;

    struct dirent *ptr; 
    struct stat st;

        if ( !S_ISDIR( st.st_mode ) ) 
            continue;

        if ( tree_depth_rec( sub_fd, max_depth, depth + 1 ) == -1 ) 
            goto out;
    }

    rv = 0; 
out:
    if ( dir )
        closedir( dir );

    return rv; 
}

    if ( tree_depth_rec( dup( root_fd ), &max_depth, 0 ) == -1 ) 
        return -1;

    return max_depth; 
}

    if ( mkdirat( dir_fd, name, 0777 ) == -1 && errno != EEXIST ) 
        err( 1, "creating directory %s", name );
    if ( ( fd = openat( dir_fd, name, O_DIRECTORY ) ) == -1 )
        err( 1, "opening newly created directory %s", name );

    return fd; 
}

int main( void ) /* demo */ 
{
    int fds[ 5 ];

    fds[ 0 ] = mkdir_or_die( AT_FDCWD, "zt.d2_root" ); 
    fds[ 1 ] = mkdir_or_die( fds[ 0 ], "a" );
    fds[ 2 ] = mkdir_or_die( fds[ 0 ], "b" );
    fds[ 3 ] = mkdir_or_die( fds[ 2 ], "c" );
    fds[ 4 ] = mkdir_or_die( fds[ 3 ], "d" );

    assert( tree_depth( fds[ 0 ] ) == 3 ); 
    assert( tree_depth( fds[ 1 ] ) == 0 );
    assert( tree_depth( fds[ 2 ] ) == 2 );
    assert( tree_depth( fds[ 3 ] ) == 1 );
    assert( tree_depth( fds[ 4 ] ) == 0 );

    for ( int i = 0; i < 5; ++i ) 
        close( fds[ i ] );

    return 0; 
}

    int rv = -1; 
    DIR *dir = fdopendir( root_fd );

    if ( !dir ) 
        goto out;

    rewinddir( dir ); 

    struct dirent *ptr; 
    struct stat st;

    while ( ( ptr = readdir( dir ) ) ) 
    {
        if ( strcmp( ptr->d_name, "." ) == 0 ||
             strcmp( ptr->d_name, ".." ) == 0 )
            continue;

        if ( fstatat( root_fd, ptr->d_name, &st, 
                      AT_SYMLINK_NOFOLLOW ) == -1 )
            goto out;

        if ( st.st_dev == dev && st.st_ino == ino ) 
        {
            dprintf( 2, "found copy at %s\n", ptr->d_name );
            ++ *count;
        }

        if ( S_ISDIR( st.st_mode ) ) 
        {
            int sub_fd = openat( root_fd, ptr->d_name,
                                 O_DIRECTORY | O_RDONLY );

            if ( count_refs_rec( sub_fd, dev, ino, count ) == -1 ) 
                goto out;
        }
    }

    rv = 0; 
out:
    if ( dir )
        closedir( dir );

    return rv; 
}

int count_refs( int root_fd, int file_fd ) 
{
    struct stat st;
    int count = 0;

    if ( fstat( file_fd, &st ) == -1 ) 
        return -1;

    if ( count_refs_rec( dup( root_fd ), st.st_dev, 
                         st.st_ino, &count ) == -1 )
        return -1;

    return count; 
}

static int mkdir_or_die( int dir_fd, const char *name ) 
{
    int fd;

    if ( mkdirat( dir_fd, name, 0777 ) == -1 && errno != EEXIST ) 
        err( 1, "creating directory %s", name );
    if ( ( fd = openat( dir_fd, name, O_DIRECTORY ) ) == -1 )
        err( 1, "opening newly created directory %s", name );

    return fd; 
}

static int create_file( int dir_fd, const char *name ) 
{
    int fd = openat( dir_fd, name, O_CREAT | O_WRONLY, 0666 );

    if ( fd == -1 ) 
        err( 1, "creating file %s", name );

    return fd; 
}

static void link_or_die( int fd_1, const char *name_1, 
                         int fd_2, const char *name_2 )
{
    if ( unlinkat( fd_2, name_2, 0 ) == -1 && errno != ENOENT )
        err( 1, "unlinking %s", name_2 );
    if ( linkat( fd_1, name_1, fd_2, name_2, 0 ) == -1 )
        err( 1, "linking %s to %s", name_1, name_2 );
}

int main( void ) /* demo */ 
{
    int fds[ 5 ];

    fds[ 0 ] = mkdir_or_die( AT_FDCWD, "zt.d3_root" ); 
    fds[ 1 ] = mkdir_or_die( fds[ 0 ], "a" );
    fds[ 2 ] = mkdir_or_die( fds[ 0 ], "b" );
    fds[ 3 ] = mkdir_or_die( fds[ 2 ], "c" );
    fds[ 4 ] = mkdir_or_die( fds[ 3 ], "d" );

    int fd_1 = create_file( fds[ 0 ], "foo_1" ); 
    int fd_2 = create_file( fds[ 1 ], "bar_1" );

    link_or_die( fds[ 0 ], "foo_1", fds[ 0 ], "foo_2" ); 
    link_or_die( fds[ 0 ], "foo_1", fds[ 1 ], "foo_3" );
    link_or_die( fds[ 1 ], "bar_1", fds[ 2 ], "bar_2" );

    assert( count_refs( fds[ 0 ], fd_1 ) == 3 ); 
    assert( count_refs( fds[ 1 ], fd_1 ) == 1 );
    assert( count_refs( fds[ 1 ], fd_2 ) == 1 );
    assert( count_refs( fds[ 2 ], fd_2 ) == 1 );
    assert( count_refs( fds[ 2 ], fd_1 ) == 0 );

    for ( int i = 0; i < 5; ++i ) 
        close( fds[ i ] );

    close( fd_1 ); 
    close( fd_2 );

    return 0; 
}

1. popisovač otevřené složky dir_fd,
2. spojovaný seznam names jmen.

• -2 v případě, kdy nebylo možné práva u některého jména ověřit (např. proto, že takový odkaz neexistuje),
• -1 při neopravitelné systémové chybě (např. chyba při načítání položek adresáře),
• 0 při úspěšném dokončení.

struct name_list 
{
    struct name_list_node *head;
};

int check_access( int dir_fd, struct name_list *names ); 

struct name_list *list( int real_dir_fd ); 

1. work_fd – popisovač složky, ze které bude staré soubory přesouvat do archivu,
2. archive_fd – popisovač archivní složky (do této složky budou staré soubory přesunuty),
3. threshold – hodnota struct timespec, která určuje nejstarší soubor, který má být ve složce work_fd zachován.

• pro určení stáří souboru použijeme časové razítko posledního zápisu (mtime),
• dojde-li ke kolizi jmen ve složce archive_fd, existující soubory budou nahrazeny (jinak ale existující soubory zůstávají nedotčené),
• dojde-li během zpracování k chybě a povaha chyby to umožňuje, procedura archive_files se pokusí zbývající položky přesto zpracovat.

• 0 značí, že vše proběhlo bez chyb,
• -1 že operace byla z důvodu chyby přerušena,
• -2 že některé soubory nebylo možné zkontrolovat nebo přesunout.

int archive_files( int work_fd, int archive_fd, 
                   struct timespec threshold );

• root_fd je popisovač otevřeného adresáře,
• name je jméno hledaného odkazu,
• flags jsou příznaky, které předá volání openat.

• existuje-li se ve stromě obyčejný soubor, na který odkazuje více než jeden odkaz (nerozhoduje, zda je tento odkaz uvnitř nebo vně prohledávaného stromu), prohledávání ukončete s výsledkem -2,
• dojde-li při zpracování podstromu k systémové chybě, výsledek bude -1.

ssize_t disk_usage( int root_fd ); 

1. client – klient pro proudový socket rodiny AF_UNIX,
2. webget – stažení webové stránky ze zadané adresy.

1. echoc – gai + connect + read
2. ntpc – (UDP) klient pro NTP
3. whois – vrátit první řádek WHOIS odpovědi
4. newsc – TCP verze 02/newsc
5. host – najde první IPv6 adresu zadaného systému
6. splice – přeposílat data z jednoho socketu do jiného

1. bcast – přeposílání datagramů na zadaný seznam adres,
2. proxy – zrcadlení datagramů na adresy uložené v nich,
3. router – přeposílání datagramů podle zadané tabulky adres,
4. xxx
5. xxx
6. xxx

1. int domain určuje tzv. komunikační doménu resp. adresovací rodinu, kterou nám socket zpřístupňuje – nejběžnějšími jsou tzv. internetové sockety (které umožňují komunikaci protokoly IPv4 a IPv6), ale prozatím se budeme zabývat jednoduššími sockety z domény AF_UNIX, které umožňují komunikaci pouze v rámci lokálního systému,
2. int type rozlišuje pro nás dva klíčové případy použití:
   • tzv. spojované sockety typu SOCK_STREAM, kdy jednotlivé spojení je reprezentováno opět socketem, který již dále pracuje jako obousměrná roura,³
   • datagramové sockety typu SOCK_DGRAM jsou jednodušší, ale zároveň se méně podobají na obyčejné soubory, a práce s nimi vyžaduje speciální funkce (nelze použít již známé read a write),
3. int protocol rozlišuje konkrétní protokol v rámci možností určených předchozími dvěma parametry – pro tento parametr budeme vždy používat hodnotu 0, která volbu vhodného protokolu přenechá operačnímu systému.

    if ( sock_fd == -1 ) 
        err( 1, "creating a unix socket" );

    if ( strlen( argv[ 1 ] ) >= sizeof sa.sun_path - 1 ) 
        errx( 1, "socket address too long, maximum is %zu",
                 sizeof sa.sun_path );

    snprintf( sa.sun_path, sizeof sa.sun_path, "%s", argv[ 1 ] ); 

    if ( write( sock_fd, message, nbytes ) == -1 ) 
        err( 1, "sending data on %s", sa.sun_path );

    return 0; 
}

• popisovač datagramového socketu,
• zřetězený seznam adres.

void bcast( int sock_fd, struct address_list *addresses ); 

1. z datagramu přečte prvních sizeof sockaddr_un bajtů,
2. zbytek datagramu přepošle na takto získanou adresu.

1. vyhledejte odesílatele ve stromě (adresa source musí být stejná jako adresa odesílatele datagramu; strom je seřazen podle source),⁶¹
2. je-li odpovídající záznam ve stromě přítomen, přepošlete datagram na adresu destination uvedenou v tomto záznamu.

void router( int sock_fd, struct address_map *root ); 

• execve
• getenv
• setenv, putenv
• O_CLOEXEC
• dup2

1. shell – spustit $SHELL -c něco
2. execp – jako execvp ale nastavit argv0 podle nalezené cesty
3. binex – spustit soubor pokud to není skript (podle ELF hlavičky)
4. uexec – spustit soubor pokud není set(gs)id?
5. withfile – přesměruje zadaný soubor na stdin zadaného příkazu
6. env – spustit příkaz s rozšířeným prostředím

1. dup – rozdělení pevných odkazů na samostatné soubory
2. dir – práce s adresářovým stromem
3. dedup – spojování identických souborů pevnými odkazy
4. httpc – klient pro stažení souboru z webu
5. httpd – jednoduchý webový server
6. execline – skripty v jednom procesu

• ve výsledném stromě ukazuje na každý obyčejný soubor právě jeden odkaz, a to tak, že
• obsah souboru, na který ukazuje více odkazů, nakopíruje do nového souboru a
• původní sdílený odkaz nahradí odkazem na tento nový soubor.

• nezáporné číslo označuje úspěch a zároveň indikuje počet nových souborů (i-uzlů), které bylo potřeba vytvořit,
• -1 indikuje situaci, kdy došlo k chybě, ale strom je zcela konzistentní (tzn. každý odkaz je buď v nedotčeném původním stavu, nebo ukazuje na správně duplikovaný soubor),
• -2 indikuje situaci, kdy došlo k chybě jak při samotné práci procedury, tak při pokusu o uvedení stromu do konzistentního stavu, a tedy ve stromě přebývají nějaké odkazy nebo soubory.

• name – ukazatel na nulou zakončený řetězec se jménem souboru;
• type – hodnota výčtového typu níže popisující typ souboru;
• error – hodnota 0, nebo informace o nastalé chybě;
• dir – v případě, že se jedná o adresář, obsahuje ukazatel na zřetězený seznam souborů, anebo NULL, pokud je adresář prázdný;
• next – ukazatel na další prvek ve stejném adresáři, anebo NULL, pokud je poslední.

struct node 
{
    char *name;
    enum file_type type;

    int error; 

    struct node *dir; 
    struct node *next;
};

• at – popisovač adresáře, ve kterém hledat složku, nebo konstanta AT_FDCWD;
• root_name – název počátečního adresáře, který se má prohledávat;
• out – výstupní ukazatel, do něhož má být uložen ukazatel na alokovanou zřetězenou strukturu.

• 0 – úspěch;
• -1 – selhání pří přístupu k některému souboru či složce;
• -2 – selhání při alokaci, což je kritická chyba, a výstupní out nechť je nastaven na NULL.

• root_fd je popisovač složky, která určuje podstrom, se kterým bude pracovat,
• attic_fd je popisovač složky, která bude sloužit jako „půda“ a kde se vytvoří odkazy na všechny redundantní soubory (tzn. ty, které byly nahrazeny tvrdým odkazem na jiný soubor).

1. řádek požadavku (resp. stavový řádek pro odpověď),
   • řádek požadavku má formu METODA cesta HTTP/1.0,
   • stavový řádek má formu HTTP/1.0 číselný_kód popis,
2. hlavičky – každé pole začíná jménem, následované dvojtečkou a textovou hodnotou, která pokračuje až do konce řádku,⁶³
3. tělo, oddělené od hlaviček prázdným řádkem.

struct http_header_list 
{
    struct http_header header;
    struct http_header_list *next;
};

struct http_request 
{
    enum http_method method;
    char *path;
    struct http_header_list *headers;
};

• cd ≡ cd,
• {cesta} ≡ /,
• … ≡ ls -hl.

• fork
• waitpid
• pipe, socketpair
• kombinace fork + exec

1. server je ta strana, která má reprezentovatelnou adresu – známe-li tuto adresu, můžeme se k serveru připojit,⁶⁵
2. server komunikuje s větším počtem protistran, typicky souběžně (i když my se v této kapitole omezíme na sekvenční odbavování klientů).

    if ( strlen( argv[ 1 ] ) >= sizeof sa.sun_path - 1 ) 
        errx( 1, "socket address too long, maximum is %zu",
                 sizeof sa.sun_path );

    snprintf( sa.sun_path, sizeof sa.sun_path, "%s", argv[ 1 ] ); 

    while ( ( client_fd = accept( sock_fd, NULL, NULL ) ) >= 0 ) 
    {

        if ( bytes == -1 ) 
            warn( "reading from client" );

        dprintf( STDOUT_FILENO, "\n" ); 

    err( 1, "accept" ); 
}

• comm_init – podprogramu předáme dvojici otevřených popisovačů a obdržíme ukazatel handle, který budeme dále používat pro komunikaci,
• comm_read, comm_write mají stejné parametry jako systémová volání read a write, ale místo popisovače souboru obdrží ukazatel handle vytvořený podprogramem comm_init,
• comm_fini uvolní veškeré zdroje spojené s předaným ukazatelem handle (včetně asociovaných popisovačů).

• pthread_create
• aktivní čekání

• pthread_mutex
• pthread_rwlock
• pthread_cond

    *count = 0; 

    if ( ( fd = openat( dir_fd, file, O_RDONLY ) ) == -1 ) 
        goto out;

    do { 

        if ( ( bytes_read = read( fd, buffer, nbytes ) ) == -1 ) 
            goto out;

        for ( int i = 0; i < bytes_read; ++i ) 
            if ( in_word && isspace( buffer[ i ] ) )
            {
                ++ *count;
                in_word = false;
            }
            else if ( !in_word && !isspace( buffer[ i ] ) )
                in_word = true;

    } while ( bytes_read > 0 ); 

    if ( in_word ) 
        ++ *count;

    result = 0; 

out: 
    if ( fd != -1 && close( fd ) == -1 )
        warn( "closing %s", file );
    return result;
}

    if ( ( orig_pos = lseek( fd_in, 0, SEEK_CUR ) ) == -1 ) 
        return -1;

    if ( lseek( fd_in, from, SEEK_SET ) == -1 ) 
        return -1;

    do { 
        if ( ( bytes_read = read( fd_in, buffer, nbytes ) ) == -1 )
            return -1;

        bytes_total += bytes_read; 
        to_write = bytes_read;
        int extra = bytes_total + from - to;

        if ( extra > 0 ) 
            to_write -= extra;

        if ( write( fd_out, buffer, to_write ) == -1 ) 
            return -1;
    } while ( bytes_read > 0 && bytes_total < to - from );

    if ( lseek( fd_in, orig_pos, SEEK_SET ) == -1 ) 
        return -1;

    return 0; 
}

int cgrep( int fd_in, char c, int fd_out ) 
{
    const int nbytes = 3;
    char buffer[ nbytes ];
    int bytes_read = 0, offset = 0, line_start = 0;
    bool matched = false;

    do { 
        if ( ( bytes_read = read( fd_in, buffer, nbytes ) ) == -1 )
            return -1;

        for ( int i = 0; i < bytes_read; ++i, ++offset ) 
        {
            if ( buffer[ i ] == c )
                matched = true;

            if ( buffer[ i ] == '\n' ) 
            {
                if ( matched &&
                     copy_span( fd_in, fd_out, line_start,
                                offset + 1 ) == -1 )
                    return -1;

                line_start = offset + 1; 
                matched = false;
            }
        }
    } while ( bytes_read > 0 );

    return 0; 
}

    if ( ( fd = openat( dir_fd, file, O_RDONLY ) ) == -1 ) 
        goto out;

    do { 
        if ( ( bytes_read = read( fd, buffer, nbytes ) ) == -1 )
            goto out;

        for ( int i = 0; i < bytes_read; ++i ) 
            counts[ buffer[ i ] ] ++;
    } while ( bytes_read > 0 );

    result = 0; 

    for ( int i = 0; i < 256; ++i ) 
        if ( counts[ i ] )
            ++ result;

out: 
    saved_errno = errno;

    if ( fd != -1 && close( fd ) == -1 ) 
        warn( "closing fd %d for %s", fd, file );

    errno = saved_errno; 
    return result;
}

void xor( char *a, const char *key, int size ) 
{
    for ( int i = 0; i < size; ++i )
        a[ i ] = a[ i ] ^ key[ i ];
}

int otp_fd( int fd_file, int fd_key, int out ) 
{
    char buf[ 4 ];
    char key[ sizeof buf ];
    int f_bytes;

    while ( ( f_bytes = read( fd_file, buf, sizeof buf ) ) > 0 ) 
    {
        int k_bytes = read( fd_key, key, f_bytes );
        if ( k_bytes == -1 ) return -2;
        if ( k_bytes != f_bytes ) return -1;

        xor( buf, key, f_bytes ); 
        if ( write( out, buf, f_bytes ) == -1 )
            return -2;
    }
    if ( f_bytes == -1 )
        return -2;

    return 0; 
}

int otp( int dir, const char* file, const char* key_file, int out ) 
{
    int ok = -2;
    int e;
    int fd_file = -1;
    int fd_key = -1;

    if ( ( fd_file= openat( dir, file, O_RDONLY ) ) == -1 ) 
        goto error;

    if ( ( fd_key = openat( dir, key_file, O_RDONLY ) ) == -1 ) 
        goto error;

    ok = otp_fd( fd_file, fd_key, out ); 

error: 
    e = errno;
    close_or_warn( fd_file, file );
    close_or_warn( fd_key, key_file );
    errno = e;
    return ok;
}

    const int msg_len = 64; 
    uint8_t buf[ msg_len + 1 ];

    struct sockaddr_un sun; 
    struct sockaddr *sa = ( struct sockaddr * ) &sun;
    socklen_t sa_size = sizeof sun;

    if ( ( bytes = recvfrom( sock_fd, buf, msg_len + 1, 
                             0, sa, &sa_size ) ) == -1 )
    {
        saved_errno = errno;
        warn( "server recvfrom" );
        goto cleanup;
    }

    if ( bytes != msg_len ) 
        return -2;

    for ( int i = 0; i < msg_len; ++i ) 
        buf[ i ] &= our_set[ i ];

    if ( ( bytes = sendto( sock_fd, buf, msg_len, 
                           0, sa, sa_size ) ) == -1 )
    {
        saved_errno = errno;
        warn( "server send" );
        goto cleanup;
    }

    assert( bytes == msg_len ); 

    if ( ( bytes = recv( sock_fd, confirmation, 2, 0 ) ) == -1 ) 
    {
        saved_errno = errno;
        warn( "server recv" );
        goto cleanup;
    }

    if ( bytes != 1 ) 
        return -2;

    if ( confirmation[ 0 ] == 1 ) 
    {
        memcpy( intersection, buf, msg_len );
        rv = 0;
    }
    else if ( confirmation[ 0 ] == 0 )
        rv = -3;
    else
        rv = -2;

cleanup: 
    errno = saved_errno;
    return rv;
}

    while ( 1 ) 
    {
        if ( ( bytes_in = recv( fd_in, buf, 4096, 0 ) ) == -1 )
            err( 1, "recv error" );

        uint32_t value = * ( uint32_t * ) ( buf + offset ); 

        if ( ntohl( value ) > thresh ) 
            if ( send( fd_out, buf, bytes_in, 0 ) == -1 )
                warn( "send" );
    }
}

    int bytes_written = write( *fd, data, size ); 

    return bytes_written; 
}

int clone_stream( int in_fd, int out1_fd, int out2_fd ) 
{
    char buf[ 512 ];
    int bytes_read;

    while ( ( bytes_read = read( in_fd, buf, sizeof buf ) ) > 0 ) 
    {
        if ( transmit( &out1_fd, buf, bytes_read ) == -1 ||
             transmit( &out2_fd, buf, bytes_read ) == -1 )
            return -1;

        if ( out1_fd == -1 && out2_fd == -1 ) 
            return 0;
    }

    return bytes_read; 
}

int bridge( int fd_1, int fd_2 ) 
{
    struct pollfd fds[ 2 ];
    for ( int i = 0; i < 2; ++i )
        fds[ i ].events = POLLIN;

    fds[ 0 ].fd = fd_1; 
    fds[ 1 ].fd = fd_2;

    char buf[ 1024 ]; 

    while ( 1 ) 
    {
        int ready = poll( fds, 2, -1 );
        if ( ready == -1 )
            return -1;

        for ( int i = 0; i < 2; ++i ) 
        {
            if ( fds[ i ].revents & POLLIN )
            {
                int bytes_read = read( fds[ i ].fd, buf, sizeof buf );
                if ( bytes_read == -1 )
                    return -1;
                if ( bytes_read == 0 )
                    return 0;

                if ( write( fds[ other( i ) ].fd, buf, bytes_read ) == -1 ) 
                    return -1;
            }
            else if ( fds[ i ].revents & POLLERR )
                return -1;
        }
    }

    return 0; 
}

    int buffered = 0; 
    int bytes_read;

    while ( ( bytes_read = read( in_fd, buf + buffered, 
                                 sizeof buf - buffered ) ) > 0 )
    {
        buffered += bytes_read;

        char *end; 
        while (( end = memchr( buf, 0xc0, buffered ) ))
        {
            int pktlen = end - buf;
            if ( send( out_fd, buf, pktlen, 0 ) == -1 )
                return -1;

            buffered -= pktlen + 1; 

            memmove( buf, buf + pktlen + 1, buffered ); 
        }
    }

    if ( bytes_read == -1 ) 
        return -1;

    if ( buffered > 0 && send( out_fd, buf, buffered, 0 ) == -1 ) 
        return -1;

    return 0; 
}

    if ( bytes == -1 ) 
        return -2;

    uint8_t sz[ 2 ]; 
    sz[ 0 ] = ( bytes & 0xff00 ) >> 8;
    sz[ 1 ] =   bytes & 0x00ff;

    memcpy( buf, sz, 2 ); 

    return write( out_fd, buf, bytes + 2 ); 
}

int packet_seq( int in_fd, int out_fd ) 
{
    while ( 1 )
        if ( seq_one( in_fd, out_fd ) < 0 )
            return errno == EPIPE ? 0 : -1;
}

    while ( tail_size > 0 ) 
    {
        int bytes_read;
        if ( lseek( fd, -tail_size, SEEK_END ) == -1 ||
             ( bytes_read = read( fd, buf, sizeof buf ) ) == -1 ||
             lseek( fd, done, SEEK_SET ) == -1 ||
             write( fd, buf, bytes_read ) == -1 )
            return -1;

        done += bytes_read; 
        tail_size -= bytes_read;
    }

    return 0; 
}

int log_stream( int in_fd, int out_fd, int log_fd, int limit ) 
{
    int half_limit = ( limit + 1 ) / 2;
    assert( half_limit > 0 );

    char buf[ 1024 ]; 
    int bytes_dropped = 0;

    // Soubor už může obsahovat nějaká data. 
    int bytes_logged = lseek( log_fd, 0, SEEK_END );
    if ( bytes_logged == -1 )
        return -1;

    int bytes_read; 
    while ( ( bytes_read = read( in_fd, buf, sizeof buf ) ) > 0 )
    {
        // Přeposlat přijatá data
        if ( write( out_fd, buf, bytes_read ) == -1 )
            return -1;

        // Spočítat novou velikost logu a o kolik bajtů přijdeme. 
        int log_length = bytes_logged + bytes_read;
        int bytes_to_discard = 0;

        while ( log_length > limit ) 
        {
            bytes_to_discard += half_limit;
            log_length -= half_limit;
        }

        bytes_dropped += bytes_to_discard; 

        // Zahodit bajty z logovacího souboru 
        if ( bytes_to_discard > 0 )
        {
            // Kolik původních bajtů má v logovacím souboru zůstat?
            int bytes_to_keep = bytes_logged - bytes_to_discard;
            if ( bytes_to_keep < 0 )
                bytes_to_keep = 0;

            // Přesunout ušetřené bajty na začátek 
            if ( bytes_to_keep > 0 && fmovetail( log_fd, bytes_to_keep ) == -1 )
                return -1;

            // Zkrátit soubor 
            if ( ftruncate( log_fd, bytes_to_keep ) == -1 )
                return -1;

            bytes_to_discard -= ( bytes_logged - bytes_to_keep ); 

            // Posunout ukazovátko na konec logu (po fmovetail může být kdekoli) 
            int bytes_kept = lseek( log_fd, 0, SEEK_END );
            if ( bytes_kept == -1 )
                return -1;

            assert( bytes_kept == bytes_to_keep ); 
        }

        assert( bytes_to_discard < bytes_read ); 
        assert( bytes_to_discard >= 0 );

        // Zapsat novou zprávu (nebo její konec, pokud máme bytes_to_discard) 
        if ( write( log_fd, buf + bytes_to_discard,
                    bytes_read - bytes_to_discard ) == -1 )
            return -1;

        // Sanity check: v logu je tolik bajtů, kolik jsme spočítali, že má být 
        bytes_logged = lseek( log_fd, 0, SEEK_END );
        if ( bytes_logged == -1 )
            return -1;
        assert( bytes_logged == log_length );
    }

    if ( bytes_read == -1 ) 
        return -1;

    return bytes_dropped; 
}

void bcast_once( int sock_fd, struct address_list *addresses ) 
{
    char buf[ 4096 ];

    struct sockaddr_un src_addr = { 0 }; 
    const socklen_t addr_un_size = sizeof( struct sockaddr_un );
    socklen_t addrlen = addr_un_size;

    int bytes = recvfrom( sock_fd, buf, sizeof buf, 0, 
                          ( struct sockaddr* )&src_addr, &addrlen );
    if ( bytes == -1 )
        warn( "recvfrom" );

    for ( struct address_list *ptr = addresses; ptr; ptr = ptr->next ) 
        if ( strcmp( src_addr.sun_path, ptr->address.sun_path ) != 0 )
        {
            if ( sendto( sock_fd, buf, bytes, 0,
                         ( struct sockaddr * )&ptr->address,
                         addr_un_size ) == -1 )
                warn( "sendto %s", ptr->address.sun_path );
        }
}

void bcast( int sock_fd, struct address_list *addresses ) 
{
    while ( 1 )
        bcast_once( sock_fd, addresses );
}

    while ( 1 ) 
    {
        int nread = recv( sock_fd, buffer, nbytes, 0 );

        if ( nread == -1 ) 
            err( 1, "recvfrom" );

        if ( nread < ( int ) sizeof addr ) 
            warnx( "incorrect datagram of size %d", nread );

        memcpy( &addr, buffer, sizeof addr ); 

        ssize_t nwrote = sendto( sock_fd, buffer + sizeof addr, 
                                 nread - sizeof( addr ), 0,
                                 ( struct sockaddr * ) &addr,
                                 sizeof addr );

        if ( nwrote == -1 ) 
            warn( "forwarding datagram" );
    }
}

const struct sockaddr_un * 
find_destination( const struct sockaddr_un* source,
                  const struct address_map *root )
{
    if ( root == NULL )
        return NULL;

    int c = strcmp( source->sun_path, root->source.sun_path ); 
    if ( c == 0 )
        return &root->destination;

    return find_destination( source, 
                             c < 0 ? root->left : root->right );
}

void router( int sock_fd, struct address_map *root ) 
{
    const size_t buffer_size = 512;
    char buffer[ buffer_size ];
    memset( buffer, 0, buffer_size );

    struct sockaddr_un from_addr; 
    socklen_t from_addr_len;

    while ( 1 ) 
    {
        from_addr_len = sizeof( struct sockaddr_un );

        ssize_t nread = recvfrom( sock_fd, buffer, buffer_size, 0, 
                                  (struct sockaddr *) &from_addr,
                                  &from_addr_len );

        if ( nread == -1 ) 
            err( 1, "recvfrom" );

        const struct sockaddr_un *to_addr = 
            find_destination( &from_addr, root );

        if ( to_addr == NULL ) 
        {
            warnx( "no route to dest" );
            continue;
        }

        ssize_t nwrote = sendto( sock_fd, buffer, nread, 0, 
                                 (struct sockaddr*) to_addr,
                                 sizeof( struct sockaddr_un ) );

        if ( nwrote == -1 ) 
            warn( "sendto" );
    }
}

• jak se pracuje s kostrami úloh,
• jak sdílet obrazovku (terminál) ve cvičení,
• jak se odevzdávají úkoly,
• kde najdete výsledky testů a jak je přečtete,
• kde najdete hodnocení kvality kódu (učitelské recenze),
• jak získáte kód pro vzájemné recenze.

1. zdrojové kódy, které máte možnost recenzovat, a to do složky ~/pb152/to_review,
2. recenze, které jste na svůj kód obdrželi (jak od spolužáků, tak od vyučujících), a to do stávajících složek zdrojového balíku (tzn. recenze na příklady z první kapitoly se Vám objeví ve složce ~/pb152/01 – že se jedná o recenzi poznáte podle jména souboru, který bude začínat uživatelským jménem autora recenze, např. xrockai.00123.p1_nhamming.cpp).

1. přesuňte se do složky ~/pb152/to_review a
2. zadejte příkaz pb152 submit, případně doplněný o seznam souborů, které hodláte odeslat (jinak se odešlou všechny, které obsahují jakýkoliv přidaný komentář).

1. přeloží Vaše řešení překladačem gcc,
2. spustí přiložené testy,
3. spustí kontrolu nástrojem valgrind.

1. Kód musí být rozdělen do ucelených jednotek (kde jednotkou rozumíme funkci, typ, modul, atd.) přiměřené velikosti, které lze studovat a používat nezávisle na sobě.
2. Jednotky musí být od sebe odděleny jasným rozhraním, které by mělo být jednodušší a uchopitelnější, než kdybychom použití jednotky nahradili její definicí.
3. Každá jednotka by měla mít jeden dobře definovaný účel, který je zachycený především v jejím pojmenování a případně rozvedený v komentáři.
4. Máte-li problém jednotku dobře pojmenovat, může to být známka toho, že dělá příliš mnoho věcí.
5. Jednotka by měla realizovat vhodnou abstrakci, tzn. měla by být obecná – zkuste si představit, že dostanete k řešení nějaký jiný (ale dostatečně příbuzný) problém: bude Vám tato konkrétní jednotka k něčemu dobrá, aniž byste ji museli (výrazně) upravovat?
6. Má-li jednotka parametr, který fakticky identifikuje místo ve kterém ji používáte (bez ohledu na to, je-li to z jeho názvu patrné), je to často známka špatně zvolené abstrakce. Máte-li parametr, který by bylo lze pojmenovat called_from_bar, je to jasná známka tohoto problému.
7. Daný podproblém by měl být vyřešen v programu pouze jednou – nedaří-li se Vám sjednotit různé varianty stejného nebo velmi podobného kódu (aniž byste se uchýlili k taktice z bodu d), může to být známka nesprávně zvolené dekompozice. Zkuste se zamyslet, není-li možné problém rozložit na podproblémy jinak.

1. Všechny entity ve zdrojovém kódu nesou anglická jména. Angličtina je univerzální jazyk programátorů.
2. Jméno musí být výstižné a popisné: v místě použití je obvykle jméno náš hlavní (a často jediný) zdroj informací o jmenované entitě. Nutnost hledat deklaraci nebo definici (protože ze jména není jasné, co volaná funkce dělá, nebo jaký má použitá proměnná význam) čtenáře nesmírně zdržuje.⁷³
3. Jména lokálního významu mohou být méně informativní: je mnohem větší šance, že význam jmenované entity si pamatujeme, protože byla definována před chvílí (např. lokální proměnná v krátké funkci).
4. Obecněji, informační obsah jména by měl být přímo úměrný jeho rozsahu platnosti a nepřímo úměrný frekvenci použití: globální jméno musí být informativní, protože jeho definice je „daleko“ (takže si ji už nepamatujeme) a zároveň se nepoužívá příliš často (takže si nepamatujeme ani to, co jsme se dozvěděli, když jsme ho potkali naposled).
5. Jméno parametru má dvojí funkci: krom toho, že ho používáme v těle funkce (kde se z pohledu pojmenování chová podobně jako lokální proměnná), slouží jako dokumentace funkce jako celku. Pro parametry volíme popisnější jména, než by zaručovalo jejich použití ve funkci samotné – mají totiž dodatečný globální význam.
6. Některé entity mají ustálené názvy – je rozumné se jich držet, protože čtenář automaticky rozumí jejich významu, i přes obvyklou stručnost. Zároveň je potřeba se vyvarovat použití takovýchto ustálených jmen pro nesouvisející entity. Typickým příkladem jsou iterační proměnné i a j.
7. Jména s velkým rozsahem platnosti by měla být také zapamatovatelná. Je vždy lepší si přímo vzpomenout na jméno funkce, kterou právě potřebuji, než ho vyhledávat (podobně jako je lepší znát slovo, než ho jít hledat ve slovníku).
8. Použitý slovní druh by měl odpovídat druhu entity, kterou pojmenovává. Proměnné a typy pojmenováváme přednostně podstatnými jmény, funkce přednostně slovesy.
9. Rodiny příbuzných nebo souvisejících entit pojmenováváme podle společného schématu (table_name, table_size, table_items – nikoliv např. items_in_table; list_parser, string_parser, set_parser; find_min, find_max, erase_max – nikoliv např. erase_maximum nebo erase_greatest nebo max_remove).
10. Jména by měla brát do úvahy kontext, ve kterém jsou platná. Neopakujte typ proměnné v jejím názvu (cars, nikoliv list_of_cars ani set_of_cars) nemá-li tento typ speciální význam. Podobně jméno nadřazeného typu nepatří do jmen jeho metod (třída list by měla mít metodu length, nikoliv list_length).
11. Dávejte si pozor na překlepy a pravopisné chyby. Zbytečně znesnadňují pochopení a (zejména v kombinaci s našeptávačem) lehce vedou na skutečné chyby způsobené záměnou podobných ale jinak napsaných jmen. Navíc kód s překlepy v názvech působí značně neprofesionálně.

1. Podobně jako jména entit, komentáře které jsou součástí kódu píšeme anglicky.⁷⁴
2. Případný komentář jednotky kódu by měl vysvětlit především „co“ a „proč“ (tzn. jaký plní tato jednotka účel a za jakých okolností ji lze použít).
3. Komentář by také neměl zbytečně duplikovat informace, které jsou k nalezení v hlavičce nebo jiné „nekomentářové“ části kódu – jestli máte například potřebu komentovat parametr funkce, zvažte, jestli by nešlo tento parametr lépe pojmenovat nebo otypovat.
4. Komentář by neměl zbytečně duplikovat samotný spustitelný kód (tzn. neměl by se zdlouhavě zabývat tím „jak“ jednotka vnitřně pracuje). Zejména jsou nevhodné komentáře typu „zvýšíme proměnnou i o jedna“ – komentář lze použít k vysvětlení proč je tato operace potřebná – co daná operace dělá si může kažďý přečíst v samotném kódu.