compiler/purify/src/io.c

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