gout

fs_inmemory.c (5763B)

---

 #include "fs_inmemory.h"
 
 #include <err.h>
 #include <limits.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "utils.h"
 
 typedef struct {
   char* path;
   char* buf;
   size_t size;
 } InMemoryFile;
 
 #define MAX_MOCK_FILES 1024
 static InMemoryFile g_files[MAX_MOCK_FILES];
 static size_t g_files_count = 0;
 
 static FILE* g_active_streams[MAX_MOCK_FILES];
 static size_t g_active_streams_count = 0;
 
 static void register_active_stream(FILE* f) {
   if (g_active_streams_count < MAX_MOCK_FILES) {
     g_active_streams[g_active_streams_count++] = f;
   }
 }
 
 static int inmemory_mkdir(const char* path, mode_t mode) {
   (void)path;
   (void)mode;
   return 0;
 }
 
 static int inmemory_mkdirp(const char* path) {
   (void)path;
   return 0;
 }
 
 static FILE* inmemory_fopen(const char* path, const char* mode) {
   if (strcmp(mode, "w") == 0) {
     InMemoryFile* file = NULL;
     for (size_t i = 0; i < g_files_count; i++) {
       if (strcmp(g_files[i].path, path) == 0) {
         file = &g_files[i];
         free(file->buf);
         file->buf = NULL;
         file->size = 0;
         break;
       }
     }
     if (!file) {
       if (g_files_count >= MAX_MOCK_FILES) {
         return NULL;
       }
       file = &g_files[g_files_count++];
       file->path = estrdup(path);
       file->buf = NULL;
       file->size = 0;
     }
     FILE* f = open_memstream(&file->buf, &file->size);
     register_active_stream(f);
     return f;
   }
   if (strcmp(mode, "r") == 0) {
     for (size_t i = 0; i < g_files_count; i++) {
       if (strcmp(g_files[i].path, path) == 0) {
         if (g_files[i].buf) {
           FILE* f = fmemopen(g_files[i].buf, g_files[i].size, "r");
           if (!f) {
             return NULL;
           }
           register_active_stream(f);
           return f;
         }
       }
     }
   }
   return NULL;
 }
 
 static int inmemory_fclose(FILE* stream) {
   for (size_t i = 0; i < g_active_streams_count; i++) {
     if (g_active_streams[i] == stream) {
       // Remove from active streams by shifting the rest down.
       if (i < g_active_streams_count - 1) {
         memmove(&g_active_streams[i], &g_active_streams[i + 1],
                 (g_active_streams_count - i - 1) * sizeof(FILE*));
       }
       g_active_streams_count--;
       return fclose(stream);
     }
   }
   return fclose(stream);  // Fallback for untracked streams.
 }
 
 const char* inmemory_fs_get_buffer(const char* path) {
   // We MUST flush all active streams to ensure buffers are up to date.
   for (size_t i = 0; i < g_active_streams_count; i++) {
     fflush(g_active_streams[i]);
   }
   for (size_t i = 0; i < g_files_count; i++) {
     if (strcmp(g_files[i].path, path) == 0) {
       return g_files[i].buf;
     }
   }
   return NULL;
 }
 
 void inmemory_fs_clear(void) {
   for (size_t i = 0; i < g_active_streams_count; i++) {
     fclose(g_active_streams[i]);
   }
   g_active_streams_count = 0;
 
   for (size_t i = 0; i < g_files_count; i++) {
     free(g_files[i].path);
     free(g_files[i].buf);
     g_files[i].path = NULL;
     g_files[i].buf = NULL;
     g_files[i].size = 0;
   }
   g_files_count = 0;
 }
 
 static int inmemory_mkstemp(char* template) {
   // We MUST return a real file descriptor because the code calls fdopen().
   return mkstemp(template);
 }
 
 static FILE* inmemory_fdopen(int fd, const char* mode) {
   return fdopen(fd, mode);
 }
 
 static int inmemory_close(int fd) {
   return close(fd);
 }
 
 static int inmemory_rename(const char* oldpath, const char* newpath) {
   // If oldpath is a real file on disk (from mkstemp), we read it into our
   // in-memory registry and then delete the disk file.
   if (access(oldpath, F_OK) == 0) {
     FILE* f = fopen(oldpath, "r");
     if (f) {
       fseek(f, 0, SEEK_END);
       long fsize = ftell(f);
       if (fsize < 0) {
         err(1, "ftell: %s", oldpath);
       }
       fseek(f, 0, SEEK_SET);
 
       char* content = malloc(fsize + 1);
       if (!content) {
         err(1, "malloc");
       }
       if (fread(content, 1, fsize, f) != (size_t)fsize) {
         err(1, "fread: %s", oldpath);
       }
       content[fsize] = '\0';
       fclose(f);
 
       // Register/Update the path in our in-memory map.
       bool found = false;
       for (size_t i = 0; i < g_files_count; i++) {
         if (strcmp(g_files[i].path, newpath) == 0) {
           free(g_files[i].buf);
           g_files[i].buf = content;
           g_files[i].size = fsize;
           found = true;
           break;
         }
       }
       if (!found) {
         if (g_files_count < MAX_MOCK_FILES) {
           InMemoryFile* file = &g_files[g_files_count++];
           file->path = estrdup(newpath);
           file->buf = content;
           file->size = fsize;
         } else {
           free(content);
         }
       }
       unlink(oldpath);
       return 0;
     }
   }
   return 0;
 }
 
 static int inmemory_chmod(const char* path, mode_t mode) {
   (void)path;
   (void)mode;
   return 0;
 }
 
 static int inmemory_access(const char* path, int amode) {
   (void)amode;
   for (size_t i = 0; i < g_files_count; i++) {
     if (strcmp(g_files[i].path, path) == 0) {
       return 0;
     }
   }
   return -1;
 }
 
 static char* inmemory_realpath(const char* path, char* resolved_path) {
   if (resolved_path) {
     estrlcpy(resolved_path, path, PATH_MAX);
     return resolved_path;
   }
   return estrdup(path);
 }
 
 static const FileSystem kStdInmemoryFs = {
 
     .mkdir = inmemory_mkdir,
     .mkdirp = inmemory_mkdirp,
     .fopen = inmemory_fopen,
     .fdopen = inmemory_fdopen,
     .fclose = inmemory_fclose,
     .close = inmemory_close,
     .mkstemp = inmemory_mkstemp,
     .rename = inmemory_rename,
     .chmod = inmemory_chmod,
     .access = inmemory_access,
     .realpath = inmemory_realpath,
 };
 
 const FileSystem* g_fs_inmemory = &kStdInmemoryFs;