Ficheiros, parte II

Na primeira parte ficou por fazer a função copy:

int copy(int fdin, int fdout);

Esta função lê todos os bytes do ficheiro indicado pelo primeiro descritor e escreve-os no segundo.

Leitura

A função read necessita de um parâmetro que é o número de bytes para ler e outro que é um buffer para guardar esses bytes. Vamos começar por declarar esse buffer:

#define BUFFER_SIZE 256

int copy(int fdin, int fdout)
{
    char buffer[BUFFER_SIZE];

    // ...
}

Agora vamos ler BUFFER_SIZE bytes de cada vez.

    int bytes_read = read(fdin, buffer, BUFFER_SIZE);
    while(bytes_read != 0)
    {
        if(bytes_read == -1)
            return -1;

        // escrever...

        bytes_read = read(fdin, buffer, BUFFER_SIZE);
    }

Neste ciclo lemos um buffer de cada vez, até ao fim do ficheiro (quando read devolver zero). Reparem que fazemos a verificação do valor de retorno e, caso seja indique um error (-1) a função devolve um erro. Esse erro vai ser tratado na função main com a função guard que já definimos.

Escrita

Agora vamos escrever os bytes que lemos no ficheiro de saída. Lembrem-se que nem sempre o número de bytes lidos é o que nós pedimos. O mesmo se passa com o número de bytes escritos. Temos de garantir que escrevemos todos os bytes que lemos. Precisamos de um ciclo que chama a função write até todos os bytes lidos serem escritos:

        int bytes_written = 0;
        do {
            bytes_written += write(fdout, ???, ???);
        } while(bytes_written < bytes)

O que temos de passar nos segundo e terceiro parâmetros? Não podemos passar BUFFER_SIZE no terceiro porque podemos não ter lido esses bytes todos. Deve ser então bytes_read.

Mas assim surge outro problema. Se tivermos lido 100 bytes (bytes_read = 100) e escrevermos 40 (bytes_written = 40) na primeira iteração, na segunda temos de escrever 60 e não 100. Temos então de escrever bytes_read – bytes_written, isto é, o número de bytes lidos que ainda não foram escritos.

E quanto ao segundo parâmetro, o buffer? Não podemos passar sempre buffer. Vejam o cenário do parágrafo anterior. Se usarmos buffer no segundo parâmetro estariamos a escrever sempre o início do buffer. Não é isso que queremos. Na segunda iteração queremos escrever os bytes que estão a partir do último que foi escrito. Ou seja, os bytes a partir de buf + bytes_written.

Ficamos então com isto:

#define BUFFER_SIZE 256

int copy(int fdin, int fdout)
{
    char buffer[BUFFER_SIZE];

    int bytes_read = read(fdin, buffer, BUFFER_SIZE);
    while(bytes_read != 0)
    {
        int bytes_written = 0;

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

        do {
            bytes_written += write(fdout,
                buf + bytes_written,
                bytes_read - bytes_written);
        } while(bytes_written < bytes)
        bytes_read = read(fdin, buffer, BUFFER_SIZE);
    }
}

Teste

Agora podemos compilar o nosso cat e testar. Para testar podemos usar dois ficheiros que temos à mão: o Makefile e o código fonte do mycat:

$ make
$ ./mycat Makefile mycat.c

Como o output não cabe todo no ecrã podemos redirecioná-lo para o less para confirmarmos que esta correcto, assim:

$ ./mycat Makefile mycat.c | less

Mas podemos fazer ainda melhor: comparar com o output do verdadeiro cat, usando o diff:

$ ./mycat Makefile mycat.c >mycat.out
$ cat Makefile mycat.c >cat.out
$ diff mycat.out cat.out

Não há diferenças entre os outputs do mycat e do cat. Isto significa que cumprímos os objectivos deste guião.

Como sempre, podem fazer download do código aqui. Podem correr o teste com o diff assim:

$ make test