compiler/purify/src/io.c

   1 #include <stdio.h>
   2 #include <sys/stat.h>
   3 #include <sys/types.h>
   4 #include <unistd.h>
   5 #include <dirent.h>
   6 #include "funcs.h"
   7 #include "hash.h"
   8 #include "error.h"
   9
  10 size_t Purify_fread (void *ptr, size_t size, size_t nmemb, FILE *stream)
  11 {
  12     if (!Purify_CheckMemoryAccess (ptr, size*nmemb, PURIFY_MemAccess_Write))
  13     {
  14         if (Purify_Error == NotOwnMemory)
  15         {
  16             Purify_Error = IllPointer;
  17             Purify_PrintError ("fread (addr=%p, size=%ld, num=%ld, file=%p)"
  18                 , ptr, size, nmemb, stream);
  19         }
  20         else
  21         {
  22             Purify_PrintAccessError ("fread()", ptr, size);
  23         }
  24     }
  25
  26     return fread (ptr, size, nmemb, stream);
  27 }
  28
  29 size_t Purify_read (int fd, void *ptr, size_t size)
  30 {
  31     if (!Purify_CheckMemoryAccess (ptr, size, PURIFY_MemAccess_Write))
  32     {
  33         if (Purify_Error == NotOwnMemory)
  34         {
  35             Purify_Error = IllPointer;
  36             Purify_PrintError ("read (fd=%d, addr=%p, size=%ld)"
  37                 , fd, ptr, size);
  38         }
  39         else
  40         {
  41             Purify_PrintAccessError ("read()", ptr, size);
  42         }
  43     }
  44
  45     return read (fd, ptr, size);
  46 }
  47
  48 char * Purify_fgets (char * ptr, int size, FILE * stream)
  49 {
  50     if (!Purify_CheckMemoryAccess (ptr, size, PURIFY_MemAccess_Write))
  51     {
  52         if (Purify_Error == NotOwnMemory)
  53         {
  54             Purify_Error = IllPointer;
  55             Purify_PrintError ("fgets (ptr=%p, size=%d, stream=%p)"
  56                 , ptr, size, stream);
  57         }
  58         else
  59         {
  60             Purify_PrintAccessError ("fgets()", ptr, size);
  61         }
  62     }
  63
  64     return fgets (ptr, size, stream);
  65 }
  66
  67 char * Purify_getcwd (char * buf, size_t size)
  68 {
  69     char * ret;
  70
  71     if (buf)
  72     {
  73         if (!Purify_CheckMemoryAccess (buf, size, PURIFY_MemAccess_Write))
  74         {
  75             if (Purify_Error == NotOwnMemory)
  76             {
  77                 Purify_Error = IllPointer;
  78                 Purify_PrintError ("getcwd (buf=%p, size=%ld)"
  79                     , buf, size);
  80             }
  81             else
  82             {
  83                 Purify_PrintAccessError ("getcwd()", buf, size);
  84             }
  85         }
  86
  87         ret = getcwd (buf, size);
  88     }
  89     else
  90     {
  91         char * ptr;
  92
  93         ptr = getcwd (NULL, size);
  94
  95         if (!ptr)
  96             return NULL;
  97
  98         if (!size)
  99         {
 100             ret = Purify_strdup (ptr);
 101
 102             if (!ret)
 103                 return NULL;
 104         }
 105         else
 106         {
 107             MemHash * hash;
 108
 109             ret = Purify_malloc (size);
 110
 111             if (!ret)
 112                 return NULL;
 113
 114             strcpy (ret, ptr);
 115
 116             hash = Purify_FindMemory (ret);
 117             Purify_SetMemoryFlags (hash, 0, strlen (ptr) + 1,
 118                 PURIFY_MemFlag_Readable|PURIFY_MemFlag_Writable
 119             );
 120         }
 121
 122         free (ptr);
 123     }
 124
 125     return ret;
 126 }
 127
 128 int Purify_stat (char * path, struct stat * st)
 129 {
 130     int len;
 131
 132     if (!Purify_CheckMemoryAccess (path, 1, PURIFY_MemAccess_Read))
 133         Purify_PrintAccessError ("stat (path, ...)", path, 1);
 134
 135     len = strlen (path)+1;
 136
 137     if (!Purify_CheckMemoryAccess (path, len, PURIFY_MemAccess_Read))
 138         Purify_PrintAccessError ("stat (path, ...)", path, len);
 139
 140     if (!Purify_CheckMemoryAccess (st, sizeof (struct stat), PURIFY_MemAccess_Write))
 141         Purify_PrintAccessError ("stat (..., stat)", st, sizeof (struct stat));
 142
 143     return stat (path, st);
 144 }
 145
 146 int Purify_lstat (char * path, struct stat * st)
 147 {
 148     int len;
 149
 150     if (!Purify_CheckMemoryAccess (path, 1, PURIFY_MemAccess_Read))
 151         Purify_PrintAccessError ("lstat (path, ...)", path, 1);
 152
 153     len = strlen (path)+1;
 154
 155     if (!Purify_CheckMemoryAccess (path, len, PURIFY_MemAccess_Read))
 156         Purify_PrintAccessError ("lstat (path, ...)", path, len);
 157
 158     if (!Purify_CheckMemoryAccess (st, sizeof (struct stat), PURIFY_MemAccess_Write))
 159         Purify_PrintAccessError ("lstat (..., stat)", st, sizeof (struct stat));
 160
 161     return lstat (path, st);
 162 }
 163
 164 int Purify_fstat (int fd, struct stat * st)
 165 {
 166     if (!Purify_CheckMemoryAccess (st, sizeof (struct stat), PURIFY_MemAccess_Write))
 167         Purify_PrintAccessError ("fstat (..., stat)", st, sizeof (struct stat));
 168
 169     return fstat (fd, st);
 170 }
 171
 172 struct dirent * Purify_readdir (DIR * dir)
 173 {
 174     static struct dirent * last_de = NULL;
 175     struct dirent * de;
 176
 177     de = readdir (dir);
 178
 179     if (de != last_de)
 180     {
 181         MemHash * hash;
 182
 183         if (last_de)
 184             Purify_RemMemory (last_de);
 185
 186         hash = Purify_AddMemory (de, sizeof (struct dirent),
 187             PURIFY_MemFlag_Writable
 188             | PURIFY_MemFlag_Readable
 189             , PURIFY_MemType_Data
 190         );
 191
 192         hash->data = "dirent";
 193
 194         last_de = de;
 195     }
 196
 197     return de;
 198 }
 199