Utilisation des appels système pour mettre en œuvre les unix commande cat

Pour mon OS de la classe I ont pour mission de mettre en œuvre Unix la commande cat avec des appels système (pas de scanf ou printf). Voici ce que j'ai obtenu jusqu'à présent:

(Édité grâce à des réponses)

#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>



main(void)
{


   int fd1; 
   int fd2;

   char *buffer1;
   buffer1 = (char *) calloc(100, sizeof(char));


   char *buffer2;
   buffer2 = (char *)calloc(100, sizeof(char));

   fd1 = open("input.in", O_RDONLY);    
   fd2 = open("input2.in", O_RDONLY);


   while(eof1){ //<-lseek condition to add here
   read (fd1, buffer1, /*how much to read here?*/ );
   write(1, buffer1, sizeof(buffer1)-1);     
   }


   while (eof2){ 

    read (fd2,buffer2, /*how much to read here?*/);  
    write(1, buffer2, sizeof(buffer2)-1);

    }

}

Les exemples que j'ai vu afficher uniquement les lire avec un nombre d'octets. Je ne sais pas combien d'octets chacun de lire les fichiers auront, alors, comment puis-je spécifier lire la dernière paramether?

Mon answer pour votre question précédente peuvent être pertinents dans votre quête pour mettre en œuvre chat en utilisant uniquement les appels système.

OriginalL'auteur andandandand | 2010-10-05

  1. 4
    • Avant vous pouvez read dans une mémoire tampon, vous devez allouer un. Sur la pile (la plus simple) ou avec mmap.
    • perror est compliquée en fonction de bibliothèque, pas un appel système.
    • exit n'est pas un appel système sous Linux. Mais _exit est.
    • Ne pas write plus d'octets que vous avez read avant.
    • Ou, en général: Lire la documentation sur tous ces appels système.

    Edit: Voici mon code, en utilisant uniquement les appels système. La gestion des erreurs est quelque peu limitée, puisque je n'ai pas envie de re-mettre en œuvre perror.

    #include <fcntl.h>
#include <unistd.h>
static int
cat_fd(int fd) {
char buf[4096];
ssize_t nread;
while ((nread = read(fd, buf, sizeof buf)) > 0) {
ssize_t ntotalwritten = 0;
while (ntotalwritten < nread) {
ssize_t nwritten = write(STDOUT_FILENO, buf + ntotalwritten, nread - ntotalwritten);
if (nwritten < 1)
return -1;
ntotalwritten += nwritten;
}
}
return nread == 0 ? 0 : -1;
}
static int
cat(const char *fname) {
int fd, success;
if ((fd = open(fname, O_RDONLY)) == -1)
return -1;
success = cat_fd(fd);
if (close(fd) != 0)
return -1;
return success;
}
int
main(int argc, char **argv) {
int i;
if (argc == 1) {
if (cat_fd(STDIN_FILENO) != 0)
goto error;
} else {
for (i = 1; i < argc; i++) {
if (cat(argv[i]) != 0)
goto error;
}
}
return 0;
error:
write(STDOUT_FILENO, "error\n", 6);
return 1;
}
    perror et de sortie n'ont pas d'importance. il n'y a qu'printf et scanf à éviter.
    alors vous n'êtes pas vraiment "la mise en œuvre de Unix la commande cat uniquement avec des appels système"
    Je les ai pris de toute façon pour éviter plus de mention de la chose dans les réponses.
    oui, vous avez raison. A enlevé le 'seul' 🙂

    OriginalL'auteur Roland Illig

  2. 3

    Vous avez besoin de lire autant d'octets que possible dans la mémoire tampon. Maintenant, vous n'avez pas de tampon pourtant, tout ce que vous avez obtenu est un pointeur vers une mémoire tampon. Ce n'est pas initialisé à quoi que ce soit. Dilemme de la poule et de l'oeuf, donc tu ne sais pas combien d'octets à lire.

    Créer une zone tampon.

    Avec quelle taille? c = (char *) calloc(100, sizeof(char));
    C'est ce que j'ai sur mon guide. Il spécifie 100 caractères, Si vous ne savez pas combien de caractères le fichier a qu'aimeriez-vous écrire sur le calloc?
    Vous ne pourriez normalement bénéficier d'une plus grande mémoire tampon, mais 100 de faire. Il suffit d'utiliser une boucle pour lire un morceau dans la mémoire tampon, et de l'écrire pièce à stdout (read() va vous dire combien il fait rempli dans le tampon, de sorte de ne pas écrire plus que ça sur chaque boucle)
    Selon la taille que vous souhaitez. Gros tampon: plus rapide, mais plus gros. Petit tampon: plus légère, mais plus lent.
    calloc n'est pas un appel système.

    OriginalL'auteur Hans Passant

  3. 2

    Il n'y a généralement pas besoin de lire le fichier en entier d'un seul trait. Le choix d'une taille de mémoire tampon qui est la même ou à un multiple de l'hôte, du système d'exploitation mémoire taille de la page est une bonne façon d'aller. 1 ou 2 X la taille de la page est probablement assez bon.

    À l'aide de tampons qui sont trop grands peuvent effectivement causer votre programme à exécuter en pire, car ils mettent la pression sur le système de mémoire virtuelle et peut causer de la pagination.

    OriginalL'auteur nategoose

  4. 2

    Vous pouvez utiliser open, fstat, mmap, madvise et write de faire un très efficace de la commande cat.

    Si spécifique à Linux vous pouvez utiliser open, fstat, fadvise et splice pour le rendre encore plus efficace de la commande cat.

    Le conseiller appels sont pour spécifier la séquence d'indicateurs qui permettra de dire que le noyau ne agressive de cache en lecture sur le fichier.

    Si vous voulez être poli pour le reste du système et de minimiser le cache tampon d'utilisation, vous pouvez faire votre copie en blocs de 32 méga-octets ou pour le conseiller DONTNEED drapeaux sur les parties déjà lu.

    Remarque:

    Le ci-dessus ne fonctionnera que si la source est un fichier. Si le fstat ne parvient pas à fournir une taille ensuite, vous devez revenir à l'utilisation d'un tampon alloué et read, write. Vous pouvez utiliser splice trop.

    OriginalL'auteur Zan Lynx

  5. 1

    Utiliser le stat fonction pour trouver la taille de vos fichiers avant de les lire. Alternativement, vous pouvez lire des morceaux jusqu'à obtenir un EOF.

    OriginalL'auteur nmichaels