compiler/clib/__arosc_nixmain.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: special main function for code which has to use special *nix features.
   6           This function gets called from a function with a similar name statically
   7           linked with the program. This is so to make the program not depend on a
   8           particular libc version.
   9
  10     Lang: english
  11 */
  12
  13 #include LC_LIBDEFS_FILE
  14
  15 #include <proto/exec.h>
  16 #include <proto/dos.h>
  17 #include <exec/lists.h>
  18 #include <dos/dos.h>
  19 #include <aros/startup.h>
  20
  21 #define DEBUG 0
  22 #include <aros/debug.h>
  23
  24 #include <setjmp.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <sys/param.h>
  28
  29 #include "__arosc_privdata.h"
  30 #include "__upath.h"
  31
  32 static BOOL clone_vars(struct MinList *old_vars);
  33 static void restore_vars(struct MinList *old_vars);
  34 static void free_vars(struct MinList *vars);
  35 static void update_PATH(void);
  36
  37 int __arosc_nixmain(int (*main)(int argc, char *argv[]), int argc, char *argv[])
  38 {
  39     struct aroscbase *aroscbase = __GM_GetBase(), *paroscbase;
  40     char *old_argv0 = NULL;
  41     char *new_argv0 = NULL;
  42     struct MinList old_vars;
  43
  44     /* Trigger *nix path handling on.  */
  45     aroscbase->acb_doupath = 1;
  46
  47     /* argv[0] usually contains the name of the program, possibly with the full
  48        path to it. Here we translate that path, which is an AmigaDOS-style path,
  49        into an unix-style one.  */
  50     if (argv && argv[0] && !aroscbase->acb_parent_does_upath)
  51     {
  52         new_argv0 = strdup(__path_a2u(argv[0]));
  53         if (new_argv0 == NULL)
  54             return RETURN_FAIL;
  55
  56         old_argv0 = argv[0];
  57         argv[0] = new_argv0;
  58     }
  59
  60     /* Here we clone environment variables. We do this because
  61        if we've been invoked as a coroutine via dos.library/RunCommand()
  62        rather than as a newly created process, then we share our env variables
  63        with the caller, but we do not want that. It's kind of wasteful to do
  64        it even if we've been started as a fresh process, though, so if we can
  65        we avoid it.
  66        The cloning does not need to be performed if flags of parent have VFORK_PARENT
  67        or EXEC_PARENT flags */
  68     paroscbase = __GM_GetBaseParent(aroscbase);
  69     if (!paroscbase || !(paroscbase->acb_flags & (VFORK_PARENT | EXEC_PARENT)))
  70     {
  71         D(bug("__arosc_nixmain: Cloning LocalVars"));
  72         if (!clone_vars(&old_vars))
  73         {
  74             __arosc_startup_error = RETURN_FAIL;
  75             goto err_vars;
  76         }
  77     }
  78
  79     /* If the PATH variable is not defined, then define it to be what CLI's path list
  80        points to.  */
  81     if (!getenv("PATH"))
  82         update_PATH();
  83
  84     /* Call the real main.  */
  85     if (setjmp(__arosc_startup_jmp_buf) == 0)
  86     {
  87         __arosc_startup_error = (*main)(argc, argv);
  88     }
  89
  90
  91     if (!paroscbase || !(paroscbase->acb_flags & (VFORK_PARENT | EXEC_PARENT)))
  92         restore_vars(&old_vars);
  93
  94 err_vars:
  95
  96     /* Restore the old argv[0].  */
  97     if (old_argv0 != NULL)
  98     {
  99         free(new_argv0);
 100         argv[0] = (char *)old_argv0;
 101     }
 102
 103     return __arosc_startup_error;
 104 }
 105
 106 /* Clone the process' environment variables list. Once this function returns,
 107    the _cloned_ vars are used in place of the old ones.
 108
 109    Returns the old list's content in the old_vars argument. Use this list only as
 110    argument to restore_vars() and for _nothing_ else.
 111
 112    If this function fails, then FALSE is returned, otherwise TRUE is returned.
 113
 114    One might argue that the whole affair is solved the wrong way around, that is
 115    clone_vars() should return the _cloned_ list and restore_vars() should be really
 116    named replace_vars() and take the cloned list as argument and replace the current
 117    one with that one, but doing it this way means breaking any programs which saved
 118    vars list's internals before invoking this program, although that is not even guaranteed
 119    to work normally, as the called program could change the env list anytime...  Well,
 120    in either case it doesn't do much of a difference, since the same amount of operations
 121    would be performed, only the order would change. */
 122
 123 BOOL clone_vars(struct MinList *old_vars)
 124 {
 125     struct MinList l;
 126     struct LocalVar *lv, *newVar;
 127     struct Process *me;
 128
 129     NEWLIST(&l);
 130
 131     me = (struct Process *)FindTask(NULL);
 132     /* Copied and adapted from rom/dos/createnewproc.c. Perhaps there should
 133        be a public function for this?  */
 134     ForeachNode(&me->pr_LocalVars, lv)
 135     {
 136         size_t copyLength;
 137
 138         if (lv->lv_Len == 0)
 139             continue;
 140
 141         copyLength = strlen(lv->lv_Node.ln_Name) + 1 + sizeof(struct LocalVar);
 142
 143         newVar = (struct LocalVar *)AllocVec(copyLength, MEMF_PUBLIC);
 144         if (newVar == NULL)
 145         {
 146             free_vars(&l);
 147             return FALSE;
 148         }
 149
 150         memcpy(newVar, lv, copyLength);
 151         newVar->lv_Node.ln_Name = (char *)newVar + sizeof(struct LocalVar);
 152         newVar->lv_Value        = AllocMem(lv->lv_Len, MEMF_PUBLIC);
 153
 154         if (newVar->lv_Value == NULL)
 155         {
 156             FreeVec(newVar);
 157             free_vars(&l);
 158             return FALSE;
 159         }
 160
 161         memcpy(newVar->lv_Value, lv->lv_Value, lv->lv_Len);
 162
 163         ADDTAIL(&l, newVar);
 164     }
 165
 166     *old_vars = me->pr_LocalVars;
 167     me->pr_LocalVars = l;
 168
 169     l.mlh_Head->mln_Pred     = (struct MinNode *)&me->pr_LocalVars.mlh_Head;
 170     l.mlh_TailPred->mln_Succ = (struct MinNode *)&me->pr_LocalVars.mlh_Tail;
 171
 172     return TRUE;
 173 }
 174
 175 /* Restores the old env var's list content */
 176 static void restore_vars(struct MinList *old_vars)
 177 {
 178     struct Process *me = (struct Process *)FindTask(NULL);
 179
 180     free_vars(&me->pr_LocalVars);
 181     me->pr_LocalVars = *old_vars;
 182 }
 183
 184 /* taken from rom/dos/createnewproc.c.  */
 185 static void free_vars(struct MinList *vars)
 186 {
 187     struct LocalVar *varNode;
 188     struct Node     *tempNode;
 189
 190     ForeachNodeSafe(vars, varNode, tempNode)
 191     {
 192         FreeMem(varNode->lv_Value, varNode->lv_Len);
 193         Remove((struct Node *)varNode);
 194         FreeVec(varNode);
 195     }
 196 }
 197
 198 /* setenv("PATH", current_cli_path, 1) */
 199 static void update_PATH(void)
 200 {
 201     typedef struct
 202     {
 203         BPTR next;
 204         BPTR lock;
 205     } PathEntry;
 206
 207     #define PE(x) ((PathEntry *)(BADDR(x)))
 208
 209     UBYTE aname[PATH_MAX]; /* PATH_MAX ought to be enough; it would be too complicated
 210                               handling aname dynamically (thanks to our sucky dos.library).  */
 211     char *PATH = NULL;
 212     size_t PATH_len = 0;
 213     PathEntry *cur;
 214     struct CommandLineInterface *cli = Cli();
 215
 216     /* No cli, no luck.  */
 217     if (cli == NULL)
 218         return;
 219
 220     for
 221     (
 222         cur = PE(cli->cli_CommandDir);
 223         cur != NULL;
 224         cur = PE(cur->next)
 225     )
 226     {
 227         char *new_PATH;
 228         const char *uname;
 229         size_t uname_len;
 230
 231         if (NameFromLock(cur->lock, aname, sizeof(aname)) == DOSFALSE)
 232             continue;
 233
 234         D(bug("aname = %s\n", aname));
 235
 236         uname = __path_a2u((const char *)aname);
 237         if (!uname)
 238             continue;
 239         uname_len = strlen(uname);
 240
 241         D(bug("uname = %s\n", uname));
 242
 243         new_PATH = realloc(PATH, PATH_len + uname_len + 1);
 244         if (!new_PATH)
 245             continue;
 246         PATH = new_PATH;
 247
 248         memcpy(PATH + PATH_len, uname, uname_len);
 249         PATH_len += uname_len;
 250         PATH[PATH_len++] = ':';
 251
 252         D(bug("PATH_len = %d, PATH = %.*s\n", PATH_len, PATH_len, PATH));
 253     }
 254
 255     if (PATH)
 256     {
 257         PATH[PATH_len ? (PATH_len - 1) : 0] = '\0';
 258
 259         setenv("PATH", PATH, 1);
 260     }
 261 }