rom/dos/setvar.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #include "dos_intern.h"
  10 #include <exec/memory.h>
  11 #include <dos/dos.h>
  12 #include <dos/dosextens.h>
  13 #include <proto/exec.h>
  14 #include <proto/utility.h>
  15 #include <exec/lists.h>
  16 #include <string.h>
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include <dos/var.h>
  22 #include <proto/dos.h>
  23
  24         AROS_LH4(BOOL, SetVar,
  25
  26 /*  SYNOPSIS */
  27         AROS_LHA(CONST_STRPTR, name, D1),
  28         AROS_LHA(CONST_STRPTR, buffer, D2),
  29         AROS_LHA(LONG        , size, D3),
  30         AROS_LHA(LONG        , flags, D4),
  31
  32 /*  LOCATION */
  33         struct DosLibrary *, DOSBase, 150, Dos)
  34
  35 /*  FUNCTION
  36         This function will set a local or environmental variable. Although
  37         it is recommended that you only use ASCII strings within variables,
  38         this is not actually required.
  39
  40         Variable names are not case sensitive.
  41
  42         SetVar() for an already existing variable changes the variable's
  43         value to "buffer".
  44
  45     INPUTS
  46         name        -   The name of the variable to set.
  47         buffer      -   The actual data of the variable.
  48         size        -   The size of the data in the buffer.
  49         flags       -   Combination of the type of variable to set (lower
  50                         8 bits of the value), and various flags which control
  51                         this function. Flags defined are:
  52
  53                         GVF_LOCAL_ONLY  -   set a local variable only,
  54                         GVF_GLOBAL_ONLY -   set a global environmental
  55                                             variable only.
  56                         GVF_SAVE_VAR    -   If GVF_GLOBAL_ONLY is set, then
  57                                             this flag will cause SetVar() to
  58                                             save the variable to ENVARC: as well
  59                                             as to ENV:.
  60                         GVF_BINARY_VAR and GVF_DONT_NULL_TERM are stored in
  61                         the lv_Flags field for local variables, but not
  62                         used otherwise by SetVar().
  63
  64                         Note the default is to set a local environmental
  65                         variable.
  66
  67                         The following variable types are defined:
  68                         LV_VAR          - local environment variable
  69                         LV_ALIAS        - shell alias
  70                         LVF_IGNORE      - internal shell use
  71
  72                         LV_VAR and LV_ALIAS should be treated as
  73                         "exclusive or".
  74
  75
  76     RESULT
  77         Zero if this function failed, non-zero otherwise.
  78
  79     NOTES
  80         It is possible to have two variables with the same name as
  81         long as they have different types.
  82
  83     EXAMPLE
  84
  85     BUGS
  86         Only type LV_VAR can be made global.
  87
  88         If you set GVF_SAVE_VAR, and this function returns failure, the
  89         variable may have still been set in ENV:.
  90
  91     SEE ALSO
  92         DeleteVar(), FindVar(), GetVar(),
  93
  94     INTERNALS
  95         See FindVar() for a description of the inner workings of local
  96         variables.
  97
  98 *****************************************************************************/
  99 {
 100     AROS_LIBFUNC_INIT
 101
 102     /* valid input? */
 103     if(name && buffer && size)
 104     {
 105         /* Local variable is default. */
 106         if((flags & GVF_GLOBAL_ONLY) == 0)
 107         {
 108             ULONG nameLen = strlen(name);
 109             struct LocalVar *lv;
 110
 111             /* does a Variable with that name already exist? */
 112             if (NULL != (lv = FindVar(name, flags)))
 113             {
 114                 /* delete old value of that existing variable */
 115                 FreeMem(lv->lv_Value,lv->lv_Len);
 116             }
 117             else
 118             {
 119                 /*
 120                 ** create a LocalVar-structure and insert it into the list
 121                 */
 122                 if (NULL != (lv = AllocVec(sizeof(struct LocalVar) + nameLen + 1,
 123                                            MEMF_CLEAR|MEMF_PUBLIC) ) )
 124                 {
 125                     struct Process  *pr = (struct Process *)FindTask(NULL);
 126                     struct LocalVar *n  = (struct LocalVar *)pr->pr_LocalVars.mlh_Head;
 127
 128                     /* init the newly created structure */
 129
 130                     lv->lv_Node.ln_Type = flags;  /* ln_Type is UBYTE! */
 131                     lv->lv_Node.ln_Name = (UBYTE *)lv + sizeof(struct LocalVar);
 132                     CopyMem(name, lv->lv_Node.ln_Name, nameLen);
 133                     lv->lv_Flags = flags & (GVF_BINARY_VAR|GVF_DONT_NULL_TERM);
 134
 135                     /*
 136                     ** First let's see whether we have to add it at the head
 137                     ** of the list as the list is still empty   OR
 138                     ** the very first element is already greater than the one
 139                     ** we want to insert
 140                     */
 141
 142                     if (n == (struct LocalVar *)&(pr->pr_LocalVars.mlh_Tail) ||
 143                         Stricmp(name, n->lv_Node.ln_Name) < 0)
 144                     {
 145                         AddHead((struct List *)&pr->pr_LocalVars,
 146                                 (struct Node *)lv);
 147                     }
 148                     else
 149                     {
 150                         /*
 151                         ** Now we can be sure that we will have to insert
 152                         ** somewhere behind the first element in the list
 153                         */
 154                         ForeachNode(&pr->pr_LocalVars, n)
 155                         {
 156                             if (Stricmp(name, n->lv_Node.ln_Name) < 0)
 157                             {
 158                                 break;
 159                             }
 160                         }
 161
 162                         if (NULL != n->lv_Node.ln_Succ)
 163                         {
 164                             Insert((struct List *)&pr->pr_LocalVars ,
 165                                    (struct Node *) lv ,
 166                                    (struct Node *) n->lv_Node.ln_Pred);
 167                         }
 168                         else
 169                         {
 170                             AddTail((struct List *)&pr->pr_LocalVars,
 171                                     (struct Node *) lv);
 172                         }
 173                     }
 174                 }
 175             }
 176
 177             /* -1 as size means: buffer contains a null-terminated string*/
 178             if (-1 == size)
 179             {
 180                 /* Do NOT add 1 byte to account for the NUL char, AmigaOS(R) doesn't
 181                    do it that way.  */
 182                 lv->lv_Len = strlen(buffer);
 183             }
 184             else
 185             {
 186                 lv->lv_Len = size;
 187             }
 188
 189             /* now get some memory for the value*/
 190             lv->lv_Value = AllocMem(lv->lv_Len, MEMF_PUBLIC);
 191
 192             if (lv->lv_Value)
 193             {
 194                 CopyMem(buffer, lv->lv_Value, lv->lv_Len);
 195
 196                 if (flags & GVF_LOCAL_ONLY)
 197                     return DOSTRUE;
 198             } /* memory for actual value */
 199         } /* set a local variable */
 200
 201         /* Ok, try and set a global variable. */
 202         if ((flags & GVF_LOCAL_ONLY) == 0)
 203         {
 204             BPTR file;
 205             /* as a standard: look for the file in ENV: if no path is
 206                given in the variable */
 207             UBYTE nameBuffer[384]= "ENV:";
 208
 209             AddPart(nameBuffer, name, 384);
 210
 211             /* Just try and open the file */
 212             file = Open(nameBuffer, MODE_NEWFILE);
 213
 214             if (file != NULL)
 215             {
 216                 /* Write the data to the file */
 217                 /* size = -1 means that the value is a null-terminated
 218                    string */
 219                 if (-1 == size)
 220                 {
 221                     Write(file, buffer, strlen(buffer));
 222                 }
 223                 else
 224                 {
 225                     Write(file, buffer, size);
 226                 }
 227
 228                 Close(file);
 229             }
 230             else
 231             {
 232                 return DOSFALSE;
 233             }
 234
 235             /* Let's see whether we're supposed to make a copy of this to
 236              * envarc also...
 237              */
 238             if (0 != (flags & GVF_SAVE_VAR))
 239             {
 240                 CopyMem("ENVARC:", nameBuffer, 8);
 241                 AddPart(nameBuffer, name, 384);
 242
 243                 file = Open(nameBuffer, MODE_NEWFILE);
 244
 245                 if (file != NULL)
 246                 {
 247                     /* Write the data to the file */
 248                     /* size = -1 means that the value is a null-terminated
 249                        string */
 250                     if (-1 == size)
 251                     {
 252                         Write(file, buffer, strlen(buffer));
 253                     }
 254                     else
 255                     {
 256                         Write(file, buffer, size);
 257                     }
 258
 259                     Close(file);
 260                 }
 261             }
 262
 263             /* We created both, bye bye */
 264             return DOSTRUE;
 265         } /* try a global variable */
 266     } /* input was valid */
 267
 268     return DOSFALSE;
 269
 270     AROS_LIBFUNC_EXIT
 271 } /* SetVar */