Les fichiers mappés en mémoires (UNIX)

int open(const char* path, int oflag, ...);

#include <fcntl.h>

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
 
int main(void)
{
   int fd; // Notre File Descriptor
   char chemin_fichier[200]; // buffer pour le chemin du fichier
   memset(chemin_fichier, 0x00, 200); // Fonction qui remplit chemin_fichier de '0', pour initialiser
   printf("Chemin du fichier à mapper : ");
   scanf("%s", chemin_fichier); // Saisie du chemin du fichier
   if (-1 == (fd = open(chemin_fichier, O_RDWR))) // Ouverture en lecture et écriture
   {
      perror("open() "); // perror affichera un message indiquant la cause de l'erreur
      exit(EXIT_FAILURE); // sortir du programme
   }
   return EXIT_SUCCESS;
}

#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int stat (const char* restrict path, struct stat* restrict buf);

...
struct stat buf;
if (-1 == stat(nom_fichier, &buf)) // Obtention de la taille, on passe l'adresse de buf car la fonction attend un pointeur!
{
   perror("stat() ");
   close(fd); // Fermeture du fichier
   exit(EXIT_FAILURE); // Si erreur on sort
}

struct stat
{
dev_t st_dev;
ino_t st_ino;
mode_t st_mode;
nlink_t st_nlink;
uid_t st_uid;
gid_t st_gid;
dev_t st_rdev;
struct timespec st_atimespec;
struct timespec st_mtimespec;
struct timespec st_ctimespec;
off_t st_size;
quad_t st_blocks;
u_long st_blksize;
u_long st_flags;
u_long st_gen;
};

#include <sys/types.h>

#include <sys/mman.h>

void* mmap(void* addr, size_t len, int prot, int flags, int fildes, off_t offset);

char* buffer;
buffer = (char*)mmap(0, (int)buf.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); // Mappage
if ((char*)-1 == buffer)
{
   perror("mmap() ");
   close(fd); // Fermeture du fichier
   exit(EXIT_FAILURE);
}
close(fd); // Fermeture du fichier

unsigned short i;
for (i = 0 ; i < (int)buf.st_size ; i++)
        buffer[i] = i+'0'; // Remplacement (+'0' pour obtenir les chiffres ASCII)

int munmap(void* start, size_t length);

munmap(buffer, (int)buf.st_size); // Desallocation

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
 
typedef unsigned short ushort;
 
int main(int argc, char* const argv[])
{
        if (argc != 2)
        {
                printf("Usage : %s <fichier>\n", argv[0]);
                exit(EXIT_FAILURE);
        }
        
        int fd; // File descriptor
        ushort i; // Compteur
        char* buffer; // Contenu fichier en memoire
        struct stat buf; // Pour la taille du fichier
        
        if (-1 == (fd = open(argv[1], O_RDWR))) // Ouverture en lecture et ecriture
        {
                perror("open() ");
                exit(EXIT_FAILURE);
        }
        if (-1 == stat(argv[1], &buf)) // Obtention de la taille
        {
                perror("stat() ");
                close(fd); // Fermeture fichier!
                exit(EXIT_FAILURE);
        }
 
        buffer = (char*)mmap(0, (int)buf.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); // Mappage
        if ((char*)-1 == buffer)
        {
                perror("mmap() ");
                close(fd); // fermeture fichier!
                exit(EXIT_FAILURE);
        }
        close(fd); // Fermeture du fichier
        printf("Contenu du fichier avant modification : %s\n", buffer);
 
        /* OPERATIONS A FAIRE ICI */
        for (i = 0 ; i < (int)buf.st_size ; i++)
                buffer[i] = i+'0'; // Remplacement (+'0' pour les chiffres ASCII)
 
        printf("Contenu du fichier apres modification : %s\n", buffer);
        munmap(buffer, (int)buf.st_size); // Desallocation & sauvegarde modifs
        
        return EXIT_SUCCESS;
}