compiler/arossupport/rt_dos.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Basic functions for ressource tracking
   6     Lang: english
   7 */
   8
   9 #include "rt.h"
  10 #if 0
  11 #define ENABLE_RT 0     /* no RT inside this file */
  12 #define RT_INTERNAL 1
  13 #include <aros/rt.h>
  14
  15 #include <exec/lists.h>
  16 #include <aros/system.h>
  17 #include <exec/tasks.h>
  18 #include <exec/ports.h>
  19 #include <exec/memory.h>
  20 #include <exec/execbase.h>
  21 #include <stdarg.h>
  22 #include <stdlib.h>
  23 #include "etask.h"
  24 #endif
  25 #include <stdio.h>
  26 #include <proto/exec.h>
  27 #include <proto/arossupport.h>
  28 #include <proto/dos.h>
  29 #include <proto/alib.h>
  30
  31 typedef struct
  32 {
  33     RTNode Node;
  34     BPTR   FH;
  35     STRPTR Path;
  36     ULONG  Mode;
  37 }
  38 FileResource;
  39
  40 static IPTR RT_Open (RTData * rtd, FileResource * rt, va_list args, BOOL * success);
  41 static IPTR RT_Close (RTData * rtd, FileResource * rt);
  42 static IPTR RT_ShowErrorFile (RTData * rtd, int, FileResource *, IPTR, int, const char * file, ULONG line, va_list);
  43 static IPTR RT_CheckFile (RTData * rtd, int desc, const char * file, ULONG line, ULONG op, va_list args);
  44
  45 static const RTDesc RT_DosResources[] =
  46 {
  47     { /* RTT_FILE */
  48         sizeof (FileResource),
  49         (RT_AllocFunc) RT_Open,
  50         (RT_FreeFunc)  RT_Close,
  51         RT_Search,
  52         (RT_ShowError) RT_ShowErrorFile,
  53         (RT_CheckFunc) RT_CheckFile,
  54     },
  55 };
  56
  57 void RT_InitDos (void)
  58 {
  59     RT_Resources[RTT_FILE] = &RT_DosResources[0];
  60 }
  61
  62 void RT_ExitDos (void)
  63 {
  64 }
  65
  66 /**************************************
  67               RT Files
  68 **************************************/
  69
  70 static IPTR RT_Open (RTData * rtd, FileResource * rt, va_list args, BOOL * success)
  71 {
  72     AROS_GET_SYSBASE_OK
  73     STRPTR path;
  74
  75     path = va_arg (args, STRPTR);
  76
  77     if (!CheckPtr (path, 0))
  78     {
  79         kprintf ("Open(): Illegal path\n"
  80                 "    path=%p at %s:%d\n"
  81             , path
  82             , rt->Node.File, rt->Node.Line
  83         );
  84         return 0ul;
  85     }
  86
  87     rt->Mode = va_arg (args, LONG);
  88
  89     rt->FH = NULL;
  90
  91     if
  92     (
  93         rt->Mode != MODE_OLDFILE
  94         && rt->Mode != MODE_NEWFILE
  95         && rt->Mode != MODE_READWRITE
  96     )
  97     {
  98         kprintf ("Open(): Illegal mode %d at %s:%d\n"
  99             , rt->Mode
 100             , rt->Node.File, rt->Node.Line
 101         );
 102     }
 103     else
 104     {
 105         rt->Path = StrDup (path);
 106
 107         if (!rt->Path)
 108         {
 109             kprintf ("Open(): RT: Out of memory\n");
 110         }
 111         else
 112         {
 113             rt->FH = Open (rt->Path, rt->Mode);
 114
 115             if (!rt->FH)
 116                 FreeVec (rt->Path);
 117         }
 118     }
 119
 120     if (rt->FH)
 121         *success = TRUE;
 122
 123     return (IPTR)(rt->FH);
 124 } /* RT_Open */
 125
 126 static IPTR RT_Close (RTData * rtd, FileResource * rt)
 127 {
 128     AROS_GET_SYSBASE_OK
 129     Close (rt->FH);
 130     FreeVec (rt->Path);
 131
 132     return TRUE;
 133 } /* RT_Close */
 134
 135 static const STRPTR GetFileMode (LONG mode)
 136 {
 137     static char buffer[64];
 138
 139     switch (mode)
 140     {
 141     case MODE_OLDFILE: return "MODE_OLDFILE";
 142     case MODE_NEWFILE: return "MODE_NEWFILE";
 143     case MODE_READWRITE: return "MODE_READWRITE";
 144     }
 145
 146     sprintf (buffer, "<illegal mode %ld>", mode);
 147
 148     return buffer;
 149 } /* GetFileMode */
 150
 151 static IPTR RT_ShowErrorFile (RTData * rtd, int rtt, FileResource * rt,
 152         IPTR ret, int mode, const char * file, ULONG line, va_list args)
 153 {
 154     if (mode != RT_EXIT)
 155     {
 156         const char * modestr = (mode == RT_FREE) ? "Close" : "Check";
 157         BPTR         fh;
 158
 159         fh = va_arg (args, BPTR);
 160
 161         switch (ret)
 162         {
 163         case RT_SEARCH_FOUND:
 164             if (rt->Node.Flags & RTNF_DONT_FREE)
 165             {
 166                 kprintf ("RT%s: Try to free read-only resource: File\n"
 167                         "    %s at %s:%d\n"
 168                         "    Added at %s:%d\n"
 169                         "    FH=%p\n"
 170                     , modestr
 171                     , modestr
 172                     , file, line
 173                     , rt->Node.File, rt->Node.Line
 174                     , rt->FH
 175                 );
 176             }
 177             break;
 178
 179         case RT_SEARCH_NOT_FOUND:
 180             kprintf ("RT%s: File not found\n"
 181                     "    %s at %s:%d\n"
 182                     "    FH=%p\n"
 183                 , modestr
 184                 , modestr
 185                 , file, line
 186                 , fh
 187             );
 188             break;
 189
 190         } /* switch */
 191     }
 192     else
 193     {
 194         kprintf ("RTExit: File was not closed\n"
 195                 "    Opened at %s:%d\n"
 196                 "    FH=%p Path=%s Mode=%s\n"
 197             , rt->Node.File, rt->Node.Line
 198             , rt->FH, rt->Path, GetFileMode (rt->Mode)
 199         );
 200     }
 201
 202     return ret;
 203 } /* RT_ShowErrorFile */
 204
 205 static IPTR RT_CheckFile (RTData * rtd, int rtt,
 206                         const char * file, ULONG line,
 207                         ULONG op, va_list args)
 208 {
 209     FileResource * rt;
 210     APTR prt = &rt;
 211
 212     if (RT_Search (rtd, rtt, (RTNode **)prt, args) != RT_SEARCH_FOUND)
 213         rt = NULL;
 214
 215     switch (op)
 216     {
 217     case RTTO_Read:
 218         {
 219             BPTR  fh;
 220             APTR  buffer;
 221             ULONG length;
 222
 223             fh     = va_arg (args, BPTR);
 224             buffer = va_arg (args, APTR);
 225             length = va_arg (args, ULONG);
 226
 227             if (!rt)
 228             {
 229                 kprintf ("Read(): Illegal filehandle\n"
 230                         "    fh=%p at %s:%d\n"
 231                     , fh
 232                     , file, line
 233                 );
 234
 235                 return -1;
 236             }
 237             else if (!CheckPtr (buffer, 0))
 238             {
 239                 kprintf ("Read(): Illegal buffer\n"
 240                         "    buffer=%p at %s:%d\n"
 241                         "    FH=%p Path=%s Mode=%s\n"
 242                         "    opened at %s:%d\n"
 243                     , buffer
 244                     , file, line
 245                     , rt->FH, rt->Path, GetFileMode (rt->Mode)
 246                     , rt->Node.File, rt->Node.Line
 247                 );
 248
 249                 return -1;
 250             }
 251             else if (!CheckArea (buffer, length, 0))
 252             {
 253                 kprintf ("Read(): Illegal buffer\n"
 254                         "    buffer=%p, size=%d at %s:%d\n"
 255                         "    FH=%p Path=%s Mode=%s\n"
 256                         "    opened at %s:%d\n"
 257                     , buffer, length
 258                     , file, line
 259                     , rt->FH, rt->Path, GetFileMode (rt->Mode)
 260                     , rt->Node.File, rt->Node.Line
 261                 );
 262
 263                 return -1;
 264             }
 265
 266             return Read (fh, buffer, length);
 267         }
 268
 269     case RTTO_Write:
 270         {
 271             BPTR  fh;
 272             APTR  buffer;
 273             ULONG length;
 274
 275             fh     = va_arg (args, BPTR);
 276             buffer = va_arg (args, APTR);
 277             length = va_arg (args, ULONG);
 278
 279             if (!rt)
 280             {
 281                 kprintf ("Write(): Illegal filehandle\n"
 282                         "    fh=%p at %s:%d\n"
 283                     , fh
 284                     , file, line
 285                 );
 286
 287                 return -1;
 288             }
 289             else if (!CheckPtr (buffer, 0))
 290             {
 291                 kprintf ("Write(): Illegal buffer\n"
 292                         "    buffer=%p at %s:%d\n"
 293                         "    FH=%p Path=%s Mode=%s\n"
 294                         "    opened at %s:%d\n"
 295                     , buffer
 296                     , file, line
 297                     , rt->FH, rt->Path, GetFileMode (rt->Mode)
 298                     , rt->Node.File, rt->Node.Line
 299                 );
 300
 301                 return -1;
 302             }
 303             else if (!CheckArea (buffer, length, 0))
 304             {
 305                 kprintf ("Write(): Illegal buffer\n"
 306                         "    buffer=%p, size=%d at %s:%d\n"
 307                         "    FH=%p Path=%s Mode=%s\n"
 308                         "    opened at %s:%d\n"
 309                     , buffer, length
 310                     , file, line
 311                     , rt->FH, rt->Path, GetFileMode (rt->Mode)
 312                     , rt->Node.File, rt->Node.Line
 313                 );
 314
 315                 return -1;
 316             }
 317
 318             return Write (fh, buffer, length);
 319         }
 320
 321     }
 322
 323     return 0L;
 324 } /* RT_CheckFile */