rom/dos/getvar.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: GetVar - Return the value of a local or global variable.
   6     Lang: English
   7 */
   8 #include <aros/debug.h>
   9 #include <dos/dos.h>
  10 #include <proto/exec.h>
  11 #include "dos_intern.h"
  12
  13 /*****************************************************************************
  14
  15     NAME */
  16 #include <dos/var.h>
  17 #include <proto/dos.h>
  18
  19         AROS_LH4(LONG, GetVar,
  20
  21 /*  SYNOPSIS */
  22         AROS_LHA(CONST_STRPTR, name,   D1),
  23         AROS_LHA(STRPTR,       buffer, D2),
  24         AROS_LHA(LONG,         size,   D3),
  25         AROS_LHA(LONG,         flags,  D4),
  26
  27 /*  LOCATION */
  28         struct DosLibrary *, DOSBase, 151, Dos)
  29
  30 /*  FUNCTION
  31         This function will return the value of a local or environmental
  32         variable in the supplied buffer.
  33
  34         It is advised to only use ASCII characters with a variable, but
  35         this is not required.
  36
  37         If GVF_BINARY_VAR is not specified, this function will stop putting
  38         characters into the destination buffer when a '\n' is hit, or the
  39         end of the buffer is reached. Otherwise it will complete fill the
  40         buffer.
  41
  42     INPUTS
  43         name    -   the name of the variable you want.
  44         buffer  -   Space to store the returned variable.
  45         size    -   Length of the buffer in bytes.
  46         flags   -   A combination of the type of variable to get (lower
  47                     8 bits) and flags that control the value of this
  48                     function. Current flags are:
  49
  50                     GVF_GLOBAL_ONLY    - only tries to get a global variable.
  51                     GVF_LOCAL_ONLY     - only tries to get a local variable.
  52                     GVF_BINARY_VAR     - do not stop at a '\n' character.
  53                     GVF_DONT_NULL_TERM - no NULL termination. This only
  54                                          applies to GVF_BINARY_VAR.
  55
  56     RESULT
  57         Will return the number of characters put in the buffer, or -1
  58         if the variable is not defined. The '\n' character if it exists
  59         will not be placed in the buffer.
  60
  61         If the value would overflow the user buffer, then the number of
  62         characters copied into the buffer will be returned and the buffer
  63         truncated.The buffer will be NULL terminated unless
  64         GVF_DONT_NULL_TERM is set.
  65
  66         IoErr() will contain either:
  67           ERROR_OBJECT_NOT_FOUND
  68               if the variable is not defined.
  69           ERROR_BAD_NUMBER
  70               if the size of the buffer is 0.
  71           the total length of the variable
  72               otherwise.
  73
  74     NOTES
  75
  76     EXAMPLE
  77
  78     BUGS
  79         LV_VAR is the only type that can be global.
  80
  81     SEE ALSO
  82         DeleteVar(), FindVar(), SetVar()
  83
  84     INTERNALS
  85         Redo the RESULT documentation.
  86
  87 *****************************************************************************/
  88 {
  89     AROS_LIBFUNC_INIT
  90
  91     D(bug("GetVar: name = \"%s\", buffer = $%lx, size = %ld, flags = $%lx\n",
  92           name, buffer, size, flags));
  93
  94     if (0 == size)
  95     {
  96         D(bug("GetVar: bad size\n"));
  97
  98         SetIoErr(ERROR_BAD_NUMBER);
  99
 100         return 0;
 101     }
 102
 103     if (name && buffer)
 104     {
 105         /* not global only? */
 106         if(0 == (flags & GVF_GLOBAL_ONLY))
 107         {
 108             /* look for a local variable */
 109             struct LocalVar *lv;
 110
 111             /* look for a variable of the given name */
 112             lv = FindVar(name, flags);
 113
 114             if (lv)
 115             {
 116                 int i;
 117                 /* which size is shorter: the buffer or the size of
 118                    the value? */
 119                 i = (size < lv->lv_Len) ? size : lv->lv_Len;
 120                 CopyMem(lv->lv_Value, buffer, i);
 121
 122                 /* were we supposed to stop after the first "\n"?
 123                    = No GVF_BINARY_VAR and no GVF_DONT_NULL_TERM
 124                 */
 125                 if (0 == (flags & GVF_BINARY_VAR))
 126                 {
 127                     int j = 0;
 128
 129                     while ((buffer[j] != '\n') && (j < i))
 130                     {
 131                         j++;
 132                     }
 133
 134                     if (j == size)
 135                     {
 136                         j = size - 1;
 137                     }
 138
 139                     buffer[j]= 0x0; /* mark end of string */
 140                     size = j;
 141                 }
 142                 else if (0 == (flags & GVF_DONT_NULL_TERM))
 143                 {
 144                     if (i == size)
 145                     {
 146                         i = size - 1;
 147                     }
 148
 149                     buffer[i] = 0x0; /* mark end of string */
 150                     size = i;
 151                 }
 152                 else
 153                 {
 154                     size = i;
 155                 }
 156
 157                 SetIoErr(lv->lv_Len);
 158                 D(bug("GetVar: return %d\n", size));
 159
 160                 return size;
 161             } /* Got lv */
 162         } /* !global only */
 163
 164         /****** GLOBAL VARIABLE TREATMENT ******/
 165
 166         if ((flags & 0xff) == LV_VAR && !(flags & GVF_LOCAL_ONLY))
 167         {
 168             BPTR file;
 169             LONG i;
 170
 171             /* as standard: look for the file in ENV: if no path is
 172                given in the variable */
 173             UBYTE filebuf[256] = "ENV:";
 174
 175             AddPart(filebuf, name, 256);
 176             file = Open(filebuf, MODE_OLDFILE);
 177
 178             if (file) /* file could be opened */
 179             {
 180                 ULONG fSize;
 181                 struct FileInfoBlock fib;
 182
 183                 if (ExamineFH(file, &fib))
 184                 {
 185                     /* fSize now contains the size of variable. */
 186                     fSize = fib.fib_Size;
 187                 }
 188                 else
 189                 {
 190                     D(bug("GetVar: can't find size\n"));
 191
 192                     return -1;
 193                 }
 194
 195                 /* We return the number of bytes actually read. */
 196                 i = Read(file, buffer, size);
 197                 Close(file);
 198
 199                 /* were we supposed to stop after the first "\n"?
 200                    = No GVF_BINARY_VAR and no GVF_DONT_NULL_TERM */
 201                 if (0 == (flags & GVF_BINARY_VAR))
 202                 {
 203                     int j = 0;
 204                     /* lets search for the first '\n' (if any) in the
 205                      * string and replace it by '\0'. */
 206                     while ((buffer[j] != '\n') && (j < i))
 207                     {
 208                         j++;
 209                     }
 210
 211                     if (j == size)
 212                     {
 213                         j = size - 1;
 214                     }
 215
 216                     buffer[j]= '\0'; /* mark end of string */
 217                     size = j;
 218                 }
 219                 else if (0 == (flags & GVF_DONT_NULL_TERM))
 220                 {
 221                     if (i == size)
 222                     {
 223                         i = size - 1;
 224                     }
 225
 226                     buffer[i] = 0x0; /* mark end of string */
 227                     size = i;
 228                 }
 229                 else
 230                 {
 231                     size = i;
 232                 }
 233
 234                 SetIoErr(fSize);
 235                 D(bug("GetVar: return %d\n", size));
 236
 237                 return size;
 238             } /* open(file) */
 239         } /* ! local file only */
 240     } /* name and buffer */
 241
 242     D(bug("GetVar: not found\n"));
 243
 244     SetIoErr(ERROR_OBJECT_NOT_FOUND);
 245
 246     return -1;
 247
 248     AROS_LIBFUNC_EXIT
 249 } /* GetVar */