The FileCopy come scrivere una funzione di File Copy in C (e Go) - pt.3

R.J.MacReady: Qualcuno in questo campo non è quello che sembra. Al momento potrebbe trattarsi di uno o due di noi. Entro la primavera, potremmo essere tutti noi.
Childs: Allora, come facciamo a sapere chi è umano? Se fossi un’imitazione, un’imitazione perfetta, come faresti a capire se fossi davvero io?

(...una premessa: questo post (parte 3 di 3) è un remake di un mio vecchio post. Ma, anche se tratta lo stesso argomento, amplia e perfeziona un po' il discorso è mi è sembrato il caso di riproporlo. Leggete e mi direte...)

Dove eravamo rimasti? Ah, si! Nell'ultimo articolo (l'avete letto vero?) avevo proposto la versione buffered della funzione cpFile(), dopo aver proposto (nel penultimo articolo) la versione unbuffered e quella "special" che funziona in kernel-space. E oggi, come promesso (e le promesse si mantengono, sempre) vi racconterò di come si può fare in Go la stessa cosa. Ma è doveroso, anche per questa terza puntata, fornire un altra immagine tratta da The Thing del Maestro John Carpenter, per ricordare che questo, come ben sapete, è un blog per programmatori cinefili...

...le copie dei file vengono meglio col fresco...

Ok, veniamo al dunque: ho scritto due versioni in Go della cpFile(), la prima si può accomunare ai tipi buffered/unbuffered già visti, mentre la seconda si può paragonare al tipo "special". Cominciamo con la versione "normal", che ho chiamato cpbase.go. Vai col codice!

// cpbase.go - un cp(1) con os.ReadFile() e os.WriteFile()
package main
import (
    "os"
    "fmt"
)
// funzione main
func main() {
    // test argomenti
    argc := len(os.Args)
    if (argc != 3) {
        // errore: numero errato di argomenti: esco
        fmt.Printf("%s: numero errato di argomenti\n", os.Args[0])
        fmt.Printf("uso: %s src dest [e.g.: %s prova.c prova.bak]\n", os.Args[0], os.Args[0])
        os.Exit(1)
    }
    // eseguo la copia
    n_copied, err := cpFile(os.Args[2], os.Args[1])
    if err != nil {
        // errore: copia fallita: esco
        fmt.Printf("%s: error: %s\n", os.Args[0], err);
        os.Exit(1)
    }
    // esco con Ok
    fmt.Printf("%s: copiati %d byte\n", os.Args[0], n_copied);
    os.Exit(0)
}
// cpFile() - copia il file <src> nel file <dest>
func cpFile(dest string, src string) (n_copied int, err error) {
    // leggo tutto il contenuto dal file sorgente e lo metto in <data []byte>
    // NOTA: non usare per file molto grandi: potrebbe non bastare la memoria
    data, err := os.ReadFile(src)
    if err != nil {
        // errore: ritorno 0 e l'errore
        return
    }
    // scrivo il contenuto sul file destinazione (specificando i permessi)
    err = os.WriteFile(dest, data, 0644)
    if err != nil {
        // errore: ritorno 0 e l'errore
        return
    }
    // set byte copiati
    n_copied = len(data)
    // ritorno il numero di byte copiati ed errore nullo
    return
}

Come avrete sicuramente notato (e letto nei dettagliatissimi commenti) il main() è praticamente identico a quello dei programmi C visti precedentemente, mentre la funzione cpFile(), pur comportandosi esattamente nello stesso modo di quella in C, è alquanto diversa e, direi, molto semplificata: leggo il sorgente (prima operazione), scrivo sulla destinazione (seconda operazione) e ricavo il numero di byte copiati (terza operazione). Praticamente sono tre linee più i tradizionali test degli errori tipici del Go, tutto qua! Il Go conferma ancora una volta di essere un vero linguaggio di alto livello.

Ma c'è un "ma". Avrete sicuramente visto la nota:

    // NOTA: non usare per file molto grandi: potrebbe non bastare la memoria

Ecco, questa versione è adatta solo per file relativamente piccoli, perché il file, prima di essere copiato nella destinazione, viene caricato completamento nello slice di byte data (di tipo []byte) che è allocato nello heap: e l'heap ha una dimensione limitata, ragionevolmente proporzionale alla memoria fisica disponibile, quindi se il file è molto grande (chessoio, 100GB) avremo un problema di memoria. Quindi questa funzione è imperfetta: non funziona con qualsiasi file e quando non funziona genera un grave errore di memoria. Se proprio volete usarla, come minimo dovrete aggiungere un controllo preliminare sulla dimensione del file sorgente per ritornare, eventualmente, un errore del tipo "errore: il file è troppo grande".

E allora passiamo alla versione "special" quella che risolve il problema appena mostrato: vai col codice!

// cpspecial.go - un cp(1) con io.Copy()
package main
import (
    "io"
    "os"
    "fmt"
)
// funzione main
func main() {
    // test argomenti
    argc := len(os.Args)
    if (argc != 3) {
        // errore: numero errato di argomenti: esco
        fmt.Printf("%s: numero errato di argomenti\n", os.Args[0])
        fmt.Printf("uso: %s src dest [e.g.: %s prova.c prova.bak]\n", os.Args[0], os.Args[0])
        os.Exit(1)
    }
    // eseguo la copia
    n_copied, err := cpFile(os.Args[2], os.Args[1])
    if err != nil {
        // errore: copia fallita: esco
        fmt.Printf("%s: error: %s\n", os.Args[0], err);
        os.Exit(1)
    }
    // esco con Ok
    fmt.Printf("%s: copiati %d byte\n", os.Args[0], n_copied);
    os.Exit(0)
}
// cpFile() - copia il file <src> nel file <dest>
func cpFile(dest string, src string) (n_copied int64, err error) {
    // apro il file sorgente
    fsrc, err := os.Open(src)
    if err != nil {
        // errore: ritorno 0 e l'errore
        return
    }
    defer fsrc.Close()  // chiusura differita
    // apro il file destinazione
    fdest, err := os.Create(dest)
    if err != nil {
        // errore: ritorno 0 e l'errore
        return
    }
    defer fdest.Close() // chiusura differita
    // copio da sorgente a destinazione usando io.Copy()
    // NOTA: è il metodo più efficiente perché usa uno stream invece della memoria
    n_copied, err = io.Copy(fdest, fsrc)
    if err != nil {
        // errore: ritorno 0 e l'errore
        return
    }
    // ritorno il numero di byte copiati ed errore nullo
    return
}

Interessante, no? Il main() è, ovviamente, invariato, mentre la funzione cpFile() è radicalmente diversa, pur mantenendo la grande compattezza di quella appena vista. Anche in questo caso sono tre operazioni: apro il file sorgente, apro (o creo, se necessario) il file destinazione e copio usando la funzione io.Copy() che genera uno stream di dati da un file all'altro e si ferma quando raggiunge l'EOF: Una cpFile()  pulita, compatta, super efficiente... e senza limitazioni sulla dimensione dei file! Mi piace.

E anche questa terza (e ultima) parte dell'articolo si può considerare conclusa. Il Go si dimostra, ancora una volta, una perfetta controparte ad alto livello del C (e non solo). Ma ricordate: tutti e due hanno ampie ragioni di essere: il C è, da sempre, il Re de linguaggi a basso livello multi-purpose (per kernel, firmware, librerie e funzioni di sistema, ecc.), mentre il Go è un fantastico linguaggio ad alto livello più adatto ad altri usi (microservizi, API Web, infrastrutture Cloud, ecc.).

E nel prossimo articolo... boh, ci devo ancora pensare. Restate sintonizzati!

Ciao, e al prossimo post!

P.S.

Dopo anni di tentennamenti ho, finalmente, deciso di aprire un cineblog! Se vi interessa lo trovate qui: Polvere di Cinema. Buona lettura!

The FileCopy come scrivere una funzione di File Copy in C (e Go) - pt.2

Childs: Beh... che facciamo?
R.J.MacReady: Perché... non aspettiamo qui ancora un po'... e vediamo che succede?

(...una premessa: questo post (parte 2 di 3) è un remake di un mio vecchio post. Ma, anche se tratta lo stesso argomento, amplia e perfeziona un po' il discorso è mi è sembrato il caso di riproporlo. Leggete e mi direte...)

Ok, riprendiamo da dove ci eravamo lasciati nell'ultimo articolo (l'avete letto vero?) e, come promesso, questa volta l'argomento sarà una versione con buffered I/O  della funzione che esegue la copia di un file (una FileCopy, per gli amici). Ma è doveroso, prima, fornire un altra immagine tratta da The Thing del Maestro John Carpenter , se no potrebbe sembrare che questo sia solo un blog di programmazione, mentre, come ben sapete, è un blog per programmatori cinefili...

...con un cappello così si programma meglio...

Allora, ripetiamo: in questa nuova versione useremo I/O bufferizzato (e quindi, per esempio, fread(3) invece di read(2)) perché l'obbiettivo questa volta è la portabilità, e cosa c'è di più portabile (nel C) che usare il contenuto di stdio.h? Il codice che vedremo tra un attimo usa lo stesso main() della versione dello scorso articolo e gli unici cambi sono interni alla funzione cpFile(). In realtà, anche la cpFile() è quasi identica da un punto di vista logico, visto che le funzioni buffered hanno una sintassi d'uso e un funzionamento molto simile alle equivalenti versioni unbuffered. Ecco, posso aggiungere che se la versione buffered viene molto diversa (esteticamente e logicamente) dalla unbuffered c'è qualcosa che non va... ma su questo punto farò una breve digressione alla fine del post. Per il momento: vai col codice!

// cpbuffered.c - un cp(1) con buffered I/O
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
// prototipi locali
off_t cpFile(const char* src, const char* dest);
// funzione main()
int main(int argc, char *argv[])
{
    // test argomenti
    if (argc != 3) {
       // errore: numero errato di argomenti: esco
        fprintf(stderr, "%s: numero errato di argomenti\n", argv[0]);
        fprintf(stderr, "uso: %s src dest [e.g.: %s prova.c prova.bak]\n", argv[0], argv[0]);
        return EXIT_FAILURE;
    }
    // eseguo la copia
    off_t n_copied;
    if ((n_copied = cpFile(argv[2], argv[1])) == -1) {
        // errore: copia fallita: esco
        fprintf(stderr, "%s: error: %s\n", argv[0], strerror(errno));
        return EXIT_FAILURE;
    }
    // esco con Ok
    printf("%s: copiati %ld byte\n", argv[0], n_copied);
    return EXIT_SUCCESS;
}
// cpFile() - copia il file <src> nel file <dest>
off_t cpFile(const char *dest, const char *src)
{
    // apro il file sorgente
    FILE *fp_in;
    if ((fp_in = fopen(src, "rb")) == NULL) {
        // ritorno errore
        return -1;
    }
    // apro il file destinazione
    FILE *fp_out;
    if ((fp_out = fopen(dest, "wb")) == NULL) {
        // errore: salvo errno della fopen(3) precedente e chiudo il file
        int save_errno = errno;
        fclose(fp_in);
        // set errno salvato (evitando quello della fclose(3)) e ritorno errore
        errno = save_errno;
        return -1;
    }
    // r/w loop per la copia usando buffered I/O
    off_t n_copied = 0;
    size_t n_read;
    char buffer[BUFSIZ];
    while ((n_read = fread(buffer, 1, sizeof(buffer), fp_in)) > 0) {
        // write buffer (con reset prudenziale di errno)
        errno = 0;
        if (fwrite(buffer, 1, n_read, fp_out) < n_read) {
            // errore: salvo errno della fwrite(3) precedente e chiudo i file
            // NOTA: se errno==0 con scrittura parziale: il disco è pieno (ENOSPC)
            int save_errno = (errno != 0) ? errno : ENOSPC;
            fclose(fp_in);
            fclose(fp_out);
            // set errno salvato (evitando quello della fclose(3)) e ritorno errore
            errno = save_errno;
            return -1;
        }
        // incremento il contatore di byte copiati
        n_copied += n_read;
    }
    // r/w loop concluso: check finale errori di lettura con ferror(3)
    if (ferror(fp_in)) {
        // errore di lettura prima del EOF: salvo errno e chiudo i file
        int save_errno = errno;
        fclose(fp_in);
        fclose(fp_out);
        // set errno salvato (evitando quello della fclose(3)) e ritorno errore
        errno = save_errno;
        return -1;
    }
    // raggiunto EOF con successo: check fclose(3) in scrittura per i buffer pendenti
    if (fclose(fp_out) != 0) {
        // errore di chiusura fp_out: salvo errno e chiudo anche fp_in
        int save_errno = errno;
        fclose(fp_in);
        // set errno salvato (evitando quello della fclose(3)) e ritorno errore
        errno = save_errno;
        return -1;
    }
    // chiudo fp_in e ritorno i byte copiati
    fclose(fp_in);
    return n_copied;
}

Ok, come vedete è ampiamente commentato e quindi è auto-esplicativo, per cui non mi dilungherò sulle singole istruzioni e/o gruppi di istruzioni (leggete i commenti! sono li per quello!), ma aggiungerò, solo, qualche dettaglio strutturale. Il main(), come anticipato, è identico a quello visto precedentemente, mentre nella cpFile() si ripetono, esattamente, le spesse operazioni della versione unbuffered, usando però fopen(3) invece di open(2), fclose(3) invece di close(2), ecc. E dove troviamo qualche differenza significativa? Solo nella parte finale, quella dopo il loop while di lettura/scrittura: in questa versione vengono fatti alcuni test sui descrittori di file fp_in e fp_out per verificare che tutto il procedimento sia andato a buon fine: nella versione unbuffered questi test erano impliciti nelle operazioni di read/write (testando se il risultato era uguale a -1), mentre che in questo caso bisogna usare una funzione a parte, ferror(3), e questo perché:

On  success,  fread()  and  fwrite() return the number of items read or
written.  This number equals the number of bytes transferred only  when
size  is 1.  If an error occurs, or the end of the file is reached, the
return value is a short item count (or zero).
...
fread() does not distinguish between end-of-file and error, and callers
must use feof(3) and ferror(3) to determine which occurred.

Quello sopra è quello che riporta la man-page di fread(3) e fwrite(3), e credo che sia una giustificazione sufficiente sul perché ho scritto il codice così. Quindi, come anticipato, le versioni buffered e unbuffered devono essere quasi sovrapponibili (a parte i test finali), e mi sembra che sia esattamente il risultato raggiunto.

Ed ora la digressione promessa: mi è capitato di trovare in rete (anche in pregevoli blog/siti di programmazione) esempi di implementazione di lettura di file con buffered I/O che usano dei loop di questo tipo:

// loop di lettura/scrittura

while (!feof(fp_in)) {

// legge e scrive un buffer

...

}

ecco, come si può commentare questo? Con una sola parola:

NO

Se uno scrive il loop in questa maniera vuol dire che non ha letto la man-page di fread(3) e fwrite(3) o l'ha letta e non ne ha capito il contenuto. Non c'è bisogno di reinventare la ruota, ripeto: fread(3) e fwrite(3) funzionano quasi nello stesso modo di read(2) e write(2), quindi, se l'esempio della cpFile() unbuffered del post precedente era buono (e lo era!), allora l'esempio del post attuale deve risultare (quasi) uguale. Il loop con un while() che testa feof(3) è corretto sintatticamente ma non lo è logicamente, perché inizia testando qualcosa che non è ancora disponibile (uhm, un test predittivo?) e che, oltretutto, non serve testare. Bah, non voglio dilungarmi ulteriormente e vi rimando alla ottima analisi contenuta qui (nel sempre ottimo stackoverflow.com).

Ovviamente spero di non aver offeso nessuno (con la digressione precedente): ricordate, errare humanum est... e, sicuramente, anche in questo blog avrò scritto in passato qualche scemata (spero non grave come quella appena mostrata). Vi assicuro, però, che sto sempre attentissimo a non proporre soluzioni che non ho avuto tempo di scrivere e provare in maniera approfondita, se no invece di un blog di programmazione artistica questo sarebbe un blog di programmazione alla speriamo che funziona...

Ok, per questa seconda puntata quanto detto può bastare. Nella prossima, come promesso nel titolo stesso, vedremo come fare un FileCopy in Go. E sarà interessante, ve lo prometto!

Ciao, e al prossimo post!

The FileCopy come scrivere una funzione di File Copy in C (e Go) - pt.1

Dr.Blair: Non so di chi fidarmi.
R.J.MacReady: Ti capisco benissimo, Blair. La fiducia è una cosa molto rara oggigiorno. Sai che cosa ti dico? Affidati solo al Signore.

(...una premessa: questo post (parte 1 di 3) è un remake di un mio vecchio post. Ma, anche se tratta lo stesso argomento, amplia e perfeziona un po' il discorso è mi è sembrato il caso di riproporlo. Leggete e mi direte...)

Ok, questo post non centra niente con The Thing, il Capolavoro Immortale del Maestro John Carpenter (a parte la piccola assonanza del nome). Anzi, è solo una scusa per celebrarlo, dato che l'ho rivisto (per la millesima volta) da poco. Comunque, dato che ci siamo, parleremo anche un po' di C...

...Capolavoro Immortale...

Con questo post vedremo come scrivere una funzione che esegue la copia di un file (una FileCopy, per gli amici), dato che i sistemi POSIX (come UNIX e Linux) non prevedono una funzione specifica di libreria per farlo. Ci sono, evidentemente, mille maniere per scriverla, e questa volta ne ho pensate due. Vai con la prima!

// cpunbuffered.c - un cp(1) con unbuffered I/O
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
// prototipi locali
off_t cpFile(const char* src, const char* dest);
// funzione main()
int main(int argc, char *argv[])
{
    // test argomenti
    if (argc != 3) {
       // errore: numero errato di argomenti: esco
        fprintf(stderr, "%s: numero errato di argomenti\n", argv[0]);
        fprintf(stderr, "uso: %s src dest [e.g.: %s prova.c prova.bak]\n", argv[0], argv[0]);
        return EXIT_FAILURE;
    }
    // eseguo la copia
    off_t n_copied;
    if ((n_copied = cpFile(argv[2], argv[1])) == -1) {
        // errore: copia fallita: esco
        fprintf(stderr, "%s: error: %s\n", argv[0], strerror(errno));
        return EXIT_FAILURE;
    }
    // esco con Ok
    printf("%s: copiati %ld byte\n", argv[0], n_copied);
    return EXIT_SUCCESS;
}
// cpFile() - copia il file <src> nel file <dest>
off_t cpFile(const char *dest, const char *src)
{
    // apro il file sorgente
    int fd_in;
    if ((fd_in = open(src, O_RDONLY)) == -1) {
        // ritorno errore
        return -1;
    }
    // apro il file destinazione
    int fd_out;
    if ((fd_out = open(dest, O_WRONLY | O_CREAT | O_TRUNC, 00644)) == -1) {
        // errore: salvo errno della open(2) precedente e chiudo il file
        int save_errno = errno;
        close(fd_in);
        // set errno salvato (evitando quello della close(2)) e ritorno errore
        errno = save_errno;
        return -1;
    }
    // r/w loop per la copia usando unbuffered I/O
    off_t n_copied = 0;
    ssize_t n_read;
    char buffer[BUFSIZ];
    while ((n_read = read(fd_in, buffer, sizeof(buffer))) > 0) {
        // write buffer
        if (write(fd_out, buffer, n_read) == -1) {
            // errore: salvo errno della write(2) precedente e chiudo i file
            int save_errno = errno;
            close(fd_in);
            close(fd_out);
            // set errno salvato (evitando quello della close(2)) e ritorno errore
            errno = save_errno;
            return -1;
        }
        // incremento il contatore di bytes copiati
        n_copied += n_read;
    }
    // chiudo i file
    close(fd_in);
    close(fd_out);
    // ritorno il numero di bytes copiati
    return n_copied;
}

Ok, come vedete è, volutamente, super-commentato, e quindi è auto-esplicativo, per cui non mi dilungherò sulle singole istruzioni e/o gruppi di istruzioni (leggete i commenti! sono li per quello!), ma aggiungerò, solo, qualche dettaglio strutturale. Il main(), in questo caso, serve solo per testare la funzione di copia, e il programma generato si comporta (a livello basico) come il comando UNIX/Linux cp(1), che è proprio quello che vogliamo emulare usando la nostra nuova funzione di libreria.

La funzione che esegue il lavoro l'ho chiamata cpFile() ed è abbastanza semplice, come avrete notato. Usa l'I/O non bufferizzato (quindi, per esempio, read(2) invece di fread(3)) e, pur essendo compattissima ed efficiente, tratta anche in maniera esaustiva gli errori ed è scritta per essere una funzione di libreria, quindi non scrive nulla su stderr e stdout ma si limita a eseguire il lavoro e a restituire un codice di ritorno che sarà il numero dei byte copiati o -1 in caso di errore. Il risultato può essere trattato dal chiamante (in questo caso il main()) per visualizzare eventuali errori usando strerror(3) ed errno(3). Tutto il lavoro viene eseguito in un loop che legge un buffer dal file sorgente e lo scrive nel file destinazione, fino alla fine del file. Il resto del codice è apertura/chiusura dei file e trattamento degli errori. Visto che usiamo l'unbuffered I/O ho dimensionato il buffer di lettura/scrittura usando la define BUFSIZ del sistema che dovrebbe garantire la dimensione ottimale per le operazioni di I/O.

Posso aggiungere che la nostra funziona cpFile() usa, evidentemente, una interfaccia GNU-specific (come già detto sopra: ritorna -1 in caso di errore), e il valore di errno viene opportunamente salvato per permettere al chiamante di verificare il problema reale che ha creato l'errore nella funzione.

Volendo si potrebbe modificare l'interfaccia per usarne una di tipo XSI-compliant (ossia: POSIX): in questo caso si dovrebbe ritornare un codice di successo (che normalmente è 0) o di errore (un numero positivo: l'errno) per permettere al chiamante le stesse attività appena viste sopra. Faccio notare, infine, che anche se l'interfaccia XSI-compliant canonica dovrebbe ritornare l'errno gestito dalla libc, è possibile, per funzioni particolari, usare degli errori user-defined che potremo, ad esempio, definire in un header apposito del progetto, ma in quel caso non potremo, ovviamente, usare la strerror(3) del sistema, ma dovremo scriverne una ad-hoc per i nostri nuovi errori.

Avevo detto che avrei proposto due versioni: fermo restando il main() (che va bene per entrambi i casi) la versione alternativa è questa:

// cpspecial.c - un cp(1) con sendfile(2)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/sendfile.h>
// prototipi locali
off_t cpFile(const char* src, const char* dest);
// funzione main()
int main(int argc, char *argv[])
{
    // test argomenti
    if (argc != 3) {
       // errore: numero errato di argomenti: esco
        fprintf(stderr, "%s: numero errato di argomenti\n", argv[0]);
        fprintf(stderr, "uso: %s src dest [e.g.: %s prova.c prova.bak]\n", argv[0], argv[0]);
        return EXIT_FAILURE;
    }
    // eseguo la copia
    off_t n_copied;
    if ((n_copied = cpFile(argv[2], argv[1])) == -1) {
        // errore: copia fallita: esco
        fprintf(stderr, "%s: error: %s\n", argv[0], strerror(errno));
        return EXIT_FAILURE;
    }
    // esco con Ok
    printf("%s: copiati %ld byte\n", argv[0], n_copied);
    return EXIT_SUCCESS;
}
// cpFile() - copia il file <src> nel file <dest>
off_t cpFile(const char *dest, const char *src)
{
    // apro il file sorgente
    int fd_in;
    if ((fd_in = open(src, O_RDONLY)) == -1) {
        // ritorno errore
        return -1;
    }
    // apro il file destinazione
    int fd_out;
    if ((fd_out = open(dest, O_WRONLY | O_CREAT | O_TRUNC, 00644)) == -1) {
        // errore: salvo errno della open(2) precedente e chiudo il file
        int save_errno = errno;
        close(fd_in);
        // set errno salvato (evitando quello della close(2)) e ritorno errore
        errno = save_errno;
        return -1;
    }
    // ottengo il size del file per la funzione sendfile(2)
    off_t n_copied = 0;
    struct stat fileinfo = {0};
    if (fstat(fd_in, &fileinfo) == -1) {
        // errore: salvo errno della fstat(2) precedente e chiudo i file
        int save_errno = errno;
        close(fd_in);
        close(fd_out);
        // set errno salvato (evitando quello della close(2)) e ritorno errore
        errno = save_errno;
        return -1;
    }
    // copio in kernel-space usando la funzione sendfile(2)
    if (sendfile(fd_out, fd_in, &n_copied, fileinfo.st_size) == -1) {
        // errore: salvo errno della sendfile(2) precedente e chiudo i file
        int save_errno = errno;
        close(fd_in);
        close(fd_out);
        // set errno salvato (evitando quello della close(2)) e ritorno errore
        errno = save_errno;
        return -1;
    }
    // chiudo i file
    close(fd_in);
    close(fd_out);
    // ritorno il numero di bytes copiati
    return n_copied;
}

Come vedete è quasi sovrapponibile alla precedente ma è diversa proprio nella parte che esegue il lavoro di copia: al posto del loop viene usata la funzione sendfile(2), che ci permette di eseguire una copia diretta e super-efficiente a livello kernel-space (mentre la prima versione lavorava in user-space).

Senza entrare nei dettagli profondi che tutto questo comporta (kernel-space e user-space dei sistemi della famiglia UNIX), mi limito a precisare che questa seconda versione è migliore della prima ma è meno portabile, visto che la sendfile(2) ha comportamenti diversi in base al sistema (per esempio su Linux si può usare solo dal Kernel 2.6.33 in avanti, mentre su macOS funziona solo dalla versione 10.5 in avanti). E già che ci siamo specifichiamo meglio: anche la prima versione (quella con read(2) e write(2)) non è completamente portabile, visto che su alcuni sistemi (tipo quello che comincia con W e che preferisco non nominare neanche...) la system call  read(2) non c'è.

Ok, per oggi può bastare. Potete già intuire che l'argomento del prossimo articolo sarà una versione con buffered I/O della funzione cpFile(), ossia una versione intrinsecamente portabile, già che userà l'I/O standard del C (quello contenuto in stdio.h, per intenderci). Non trattenete il respiro nell'attesa, mi raccomando...

Ciao, e al prossimo post!